返回专栏
· 20 分钟阅读

Streaming 流式响应机制:大语言模型如何实现逐 Token 实时输出?


一、什么是 Streaming?

Streaming(流式响应)是一种将数据分块、持续传输给客户端的通信机制。

在传统非流式响应(Non-streaming)模式下,服务端通常需要等待模型完成整个回答,再将完整结果返回给客户端。

例如,用户提出:

请解释 Transformer 的工作原理。

模型可能需要生成数百甚至数千个 Token。非流式模式下,用户可能需要等待整个回答生成完成才能看到内容。

Streaming 则不同。

模型每生成一部分内容,服务端就可以将其发送给客户端,客户端持续接收并展示。

两种模式的主要区别:

对比维度 非流式响应 流式响应
返回方式 一次性返回完整结果 分块持续返回
首次可见内容 通常需要等待完整生成 可以提前展示
用户体验 容易产生长时间等待感 更接近实时交互
连接状态 请求完成后结束 生成期间保持连接
数据处理 一次性解析 持续解析和累积
适用场景 短文本、批处理 对话、长文本、实时交互

需要区分两个概念:

  • 模型生成: 模型逐步预测并生成 Token。
  • Streaming 传输: 服务端将已经生成的内容分块发送给客户端。

模型内部逐 Token 生成,并不意味着网络必须逐 Token 发送。服务端可以对多个 Token 进行缓冲和合并,再组成一个数据块传输。

二、Streaming 的整体工作流程

一个典型的大模型流式响应系统包含客户端、应用服务、模型推理服务和网络传输层。

flowchart TD
    A["用户提交请求"] --> B["客户端发起 HTTP 请求"]
    B --> C["应用服务接收请求"]
    C --> D["调用模型推理服务"]
    D --> E["模型执行 Prefill"]
    E --> F["模型逐步 Decode"]
    F --> G["生成新的 Token"]
    G --> H["服务端组织响应数据块"]
    H --> I["通过流式连接发送"]
    I --> J["客户端接收数据块"]
    J --> K["解析并更新界面"]
    K --> L{"生成是否完成"}
    L -->|"否"| F
    L -->|"是"| M["发送结束事件"]
    M --> N["关闭流式连接"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49
    style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F

整个过程可以分为几个关键阶段:

  1. 建立连接: 客户端向服务端发起流式请求。
  2. 模型推理: 模型处理输入并开始生成内容。
  3. 数据分块: 服务端将生成内容封装为一个或多个数据块。
  4. 持续传输: 数据块通过网络连接持续发送。
  5. 客户端解析: 客户端解析数据块并更新界面。
  6. 结束处理: 模型完成生成,服务端发送结束标记并关闭连接。

Streaming 并不会改变模型的核心生成算法,它主要改变的是推理结果的交付方式。

三、Streaming 与 Token 生成机制

理解 Streaming,需要先理解大语言模型的自回归生成机制。

1. 模型逐 Token 生成

以 Decoder-only Transformer 为例,模型根据已有上下文预测下一个 Token。

假设用户输入:

人工智能的发展方向是

模型可能依次生成:

多模态
融合
与
智能体
应用
。

其生成过程可以抽象为:

flowchart TD
    A["输入 Prompt"] --> B["Transformer 计算"]
    B --> C["生成下一个 Token"]
    C --> D["将 Token 加入上下文"]
    D --> E{"是否满足停止条件"}
    E -->|"否"| B
    E -->|"是"| F["完成生成"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

每轮 Decode 通常生成一个新的 Token,然后将其加入后续生成所使用的上下文。

在实际推理中,模型还会结合 KV Cache 复用历史计算结果,避免重复计算历史 Token 的 Key 和 Value。

2. Token 不等于字符

一个 Token 可能对应:

  • 一个完整单词。
  • 一个汉字。
  • 多个字符。
  • 一个词语片段。
  • 标点符号。
  • 特殊控制标记。

例如,下面的文本:

Streaming 流式响应

可能被切分为多个 Token,而不是按照空格或字符逐个生成。

因此,Streaming 中的一个数据块不一定对应一个完整单词,也不一定对应一个完整句子。

3. Token 生成与网络传输不是一回事

这是理解 Streaming 时最容易出现的误区。

模型可以逐 Token 生成,但推理服务通常不会保证每生成一个 Token 就立即发送一次网络数据。

原因包括:

  • 网络传输存在固定开销。
  • 多次小数据包可能降低传输效率。
  • 服务端可能进行缓冲。
  • 推理框架可能批量处理输出。
  • 网关、代理和客户端可能进一步缓冲数据。

例如,模型连续生成:

人工
智能
正在
改变
软件
开发
。

服务端可能将这些 Token 合并为:

人工智能正在改变软件开发。

再发送给客户端。

因此:

Token 是模型生成的基本单位,Chunk 是流式传输的数据单位,两者并不等价。

四、Streaming 的核心传输机制

Streaming 不只是模型输出方式,还涉及应用协议、网络传输和客户端解析。

常见实现方式包括:

  1. HTTP Chunked Transfer Encoding。
  2. Server-Sent Events(SSE)。
  3. WebSocket。
  4. 基于 HTTP 的其他流式传输协议。

这些技术所处层次不同,不能简单认为它们是同一种协议。

1. HTTP Chunked Transfer Encoding

HTTP Chunked Transfer Encoding 是 HTTP/1.1 中的一种分块传输编码机制。

在传统 HTTP 响应中,服务端通常可以通过 Content-Length 指定响应体的完整长度。

但对于动态生成的内容,服务端在生成开始时往往无法确定最终响应体长度。

Chunked Transfer Encoding 允许服务端将响应体拆分为多个数据块逐步发送,而不需要预先知道完整长度。

示意:

HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

5
Hello
6
 World
0

这里:

  • 每个数据块前面包含该块的十六进制字节长度。
  • 5 表示后续数据块包含 5 个字节。
  • 6 表示后续数据块包含 6 个字节。
  • 0 表示响应体传输结束。

需要注意:

HTTP/1.1 的 Chunked Transfer Encoding 是一种传输编码机制,不等于 SSE。

HTTP/2 不使用 HTTP/1.1 的 Transfer-Encoding: chunked 机制,而是通过 HTTP/2 DATA Frames 承载响应数据。

HTTP/3 则基于 QUIC 传输数据。

应用层的流式响应逻辑可以保持相似,但底层传输方式可能不同。

2. Server-Sent Events(SSE)

SSE 是一种基于 HTTP 的服务器向客户端单向推送事件的机制。

在大模型应用中,SSE 是非常常见的流式响应实现方式。

典型响应头:

HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

SSE 使用特定的文本格式组织事件。

例如:

data: {"content":"人工智能"}

data: {"content":"正在改变"}

data: {"content":"软件开发"}

data: [DONE]

每个事件通常以空行结束。

SSE 支持的常见字段包括:

字段 作用
data 事件数据
event 事件类型
id 事件标识
retry 建议客户端重连等待时间

例如:

event: message
id: 101
data: {"content":"Hello"}

客户端可以通过浏览器的 EventSource 接口接收 SSE 事件。

不过,原生 EventSource 主要适用于 GET 请求,且不能自由设置任意请求头。

如果大模型 API 需要通过 POST 发送复杂 JSON 请求,前端通常使用 fetch() 读取响应流,或者通过后端代理完成 SSE 转发。

3. WebSocket

WebSocket 是一种支持双向通信的网络协议。

与 SSE 不同,WebSocket 建立连接后,客户端和服务端都可以主动发送消息。

典型交互:

flowchart TD
    A["客户端发起连接请求"] --> B["HTTP Upgrade 握手"]
    B --> C["建立 WebSocket 连接"]
    C --> D["客户端发送消息"]
    D --> E["服务端处理请求"]
    E --> F["服务端发送流式数据"]
    F --> G["客户端持续接收"]
    G --> H{"是否需要继续交互"}
    H -->|"是"| D
    H -->|"否"| I["关闭 WebSocket 连接"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#E5F0E9,stroke:#83A995,color:#315D49

WebSocket 更适合:

  • 实时语音交互。
  • 双向实时通信。
  • 多轮持续交互。
  • 需要客户端随时发送控制消息的场景。
  • 实时状态同步。

但 WebSocket 并不是大模型流式响应的必选方案。

对于普通文本生成,HTTP SSE 通常已经足够。

4. SSE 与 WebSocket 的区别

对比维度 SSE WebSocket
通信方向 服务端向客户端单向推送 双向通信
底层基础 HTTP WebSocket 协议
数据格式 UTF-8 文本事件 文本或二进制消息
连接方式 HTTP 长连接 Upgrade 握手后建立连接
自动重连 浏览器 EventSource 支持 通常需要应用层实现
复杂度 相对简单 相对复杂
典型场景 文本流式响应 实时双向交互

选择时不应简单认为 WebSocket 一定比 SSE 更快。

真正影响延迟的因素还包括模型推理速度、网络质量、服务端缓冲、代理配置和客户端处理能力。

五、Streaming 的服务端实现

服务端需要完成三个核心任务:

  1. 接收模型生成的数据。
  2. 将数据转换为流式响应格式。
  3. 持续写入 HTTP 响应。

以 Python 为例,可以使用 FastAPI 构建一个简化的 SSE 服务。

1. 基础 SSE 服务

import asyncio
import json

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()


async def generate_text():
    tokens = [
        "Streaming",
        " 是",
        " 一种",
        " 流式",
        "响应",
        "机制",
        "。"
    ]

    for token in tokens:
        event = {
            "content": token
        }

        yield f"data: {json.dumps(event, ensure_ascii=False)}\n\n"

        await asyncio.sleep(0.2)

    yield "data: [DONE]\n\n"


@app.get("/stream")
async def stream():
    return StreamingResponse(
        generate_text(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no"
        }
    )

这里的 generate_text() 是一个异步生成器。

每次执行 yield,都会向响应流提供一段数据。

StreamingResponse 负责将这些数据持续发送给客户端。

几个关键点:

  • async def:定义异步函数。
  • yield:逐步产生响应数据。
  • text/event-stream:声明 SSE 内容类型。
  • \n\n:标记一个 SSE 事件结束。
  • X-Accel-Buffering: no:在使用 Nginx 时,可用于关闭该响应的代理缓冲。

示例中的 asyncio.sleep() 仅用于模拟 Token 生成间隔,真实系统应当消费模型推理服务产生的流。

2. 接入真实模型推理服务

真实项目中,服务端通常需要调用模型 API,并将模型返回的流式数据转发给前端。

整体结构:

flowchart TD
    A["前端请求"] --> B["FastAPI 服务"]
    B --> C["调用模型 API"]
    C --> D["接收模型 Stream"]
    D --> E["解析模型事件"]
    E --> F["提取文本或结构化内容"]
    F --> G["封装为 SSE 事件"]
    G --> H["持续发送给前端"]
    H --> I["前端解析并展示"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

生产环境中还需要处理:

  • 模型 API 的连接超时。
  • 客户端断开后的资源释放。
  • 模型生成异常。
  • 代理层缓冲。
  • 多轮对话的请求状态。
  • 结束事件和错误事件。
  • 客户端取消请求后的推理任务终止。

特别需要注意:客户端断开连接,不代表模型推理服务一定会自动停止生成。应用程序需要将取消信号传递给底层模型请求,避免无意义地继续消耗 GPU 资源。

六、客户端如何接收 Streaming 数据?

服务端负责持续发送,客户端则需要持续读取、解析和更新页面。

1. 使用 Fetch 读取响应流

浏览器的 fetch() 可以通过 ReadableStream 读取 HTTP 响应体。

简化示例:

async function streamResponse() {
    const response = await fetch("/stream");

    if (!response.ok) {
        throw new Error("请求失败");
    }

    if (!response.body) {
        throw new Error("浏览器不支持响应流");
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();

    let buffer = "";

    while (true) {
        const { value, done } = await reader.read();

        if (done) {
            break;
        }

        buffer += decoder.decode(value, {
            stream: true
        });

        const events = buffer.split("\n\n");

        buffer = events.pop() ?? "";

        for (const event of events) {
            const dataLine = event
                .split("\n")
                .find(line => line.startsWith("data:"));

            if (!dataLine) {
                continue;
            }

            const data = dataLine.slice(5).trim();

            if (data === "[DONE]") {
                return;
            }

            const result = JSON.parse(data);

            console.log(result.content);
        }
    }

    buffer += decoder.decode();

    if (buffer.trim()) {
        // 根据实际协议处理最后一个未完成事件
    }
}

这里涉及几个重要 API:

API 作用
response.body 获取响应体流
getReader() 获取流读取器
reader.read() 读取下一个数据块
TextDecoder 将字节解码为文本
decode() 解码字节数据
stream: true 保留不完整字符的解码状态

2. 为什么需要 buffer?

这是 Streaming 客户端开发中非常容易出错的地方。

网络传输的数据块与 SSE 事件并不一定一一对应。

例如,服务端发送:

data: {"content":"Hello"}

data: {"content":"World"}

客户端可能收到以下任意形式:

情况一:一次收到完整事件

data: {"content":"Hello"}

情况二:一次收到多个事件

data: {"content":"Hello"}

data: {"content":"World"}

情况三:一个事件被拆成多个数据块

第一次:

data: {"cont

第二次:

ent":"Hello"}

如果客户端每次 reader.read() 后都直接解析 JSON,就可能出现解析失败。

因为 read() 返回的是传输数据块,不保证对应完整的 SSE 事件,更不保证对应完整的 JSON 对象。

正确处理方式是:

  1. 将新数据追加到缓冲区。
  2. 按 SSE 事件分隔符寻找完整事件。
  3. 只解析已经完整接收的事件。
  4. 保留最后一个不完整片段。
  5. 等待后续数据继续拼接。

需要注意,真实 SSE 解析器还应正确处理 event、id、多行 data、注释行、CRLF 换行以及流结束时尚未完整分隔的最后一个事件。

生产环境优先使用经过验证的 SSE 解析库,而不是长期依赖简化的字符串切分逻辑。

3. TextDecoder 为什么需要 stream 模式?

网络传输的是字节,而不是天然完整的 UTF-8 字符。

一个中文字符可能由多个 UTF-8 字节组成。

假设某个字符的字节序列被网络分成两部分:

数据块 A:字符的前两个字节
数据块 B:字符剩余的一个字节

如果每次都独立解码,第一块可能因为字符不完整而产生替换字符。

使用:

decoder.decode(value, {
    stream: true
});

可以让解码器保留尚未完成的字符字节,等待后续数据到达。

因此,Streaming 客户端需要同时处理两类边界:

  • UTF-8 字符边界。
  • SSE 事件边界。

它们不是同一层面的边界,不能混为一谈。

七、Streaming 与 Prefill、Decode 的关系

Streaming 是传输层的机制,而 Prefill 和 Decode 是大模型推理过程中的计算阶段。

两者属于不同层次,但密切相关。

1. Prefill 阶段

Prefill 负责处理完整输入 Prompt。

主要工作包括:

  • Tokenizer 编码。
  • Embedding 映射。
  • Transformer 层计算。
  • 生成 Prompt 对应的 KV Cache。
  • 计算第一个输出 Token 的预测分布。

Prefill 通常需要处理整个输入序列,因此它的计算量与 Prompt 长度密切相关。

在一般的自回归生成流程中,模型需要完成 Prefill,才能开始生成第一个输出 Token。

2. Decode 阶段

Decode 负责逐步生成后续 Token。

每轮 Decode 通常会:

  • 输入当前需要处理的新 Token。
  • 读取历史 KV Cache。
  • 执行 Transformer 计算。
  • 生成下一个 Token。
  • 更新 KV Cache。

Decode 阶段是流式文本内容的主要来源。

3. Streaming 与推理阶段的对应关系

flowchart TD
    A["用户提交 Prompt"] --> B["Tokenizer 编码"]
    B --> C["Prefill 阶段"]
    C --> D["建立 KV Cache"]
    D --> E["计算首个输出 Token"]
    E --> F["服务端发送首批数据"]
    F --> G["Decode 阶段"]
    G --> H["生成后续 Token"]
    H --> I["服务端持续发送数据"]
    I --> J["客户端持续展示"]
    J --> K{"是否生成结束"}
    K -->|"否"| G
    K -->|"是"| L["结束流式响应"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意一个细节:

Prefill 并不一定意味着用户必须等待整个 Prompt 的所有计算完成后才看到任何响应元数据。服务端可以提前发送响应头、状态事件或进度信息。

但对于通常的自回归文本生成,真正的首个生成 Token 仍需要模型完成必要的 Prefill 计算。

八、Streaming 的关键性能指标

评价流式响应性能,不能只看整个请求的总耗时。

需要分别观察模型推理速度、首个内容到达时间和网络传输表现。

1. TTFT:Time To First Token

TTFT 表示从请求开始到客户端收到第一个生成 Token 所经过的时间。

可以抽象为:

TTFT = T_{\text{first token received}} - T_{\text{request start}}

TTFT 通常包含: