Streaming LLM trong Next.js: khách thấy chữ ngay, không chờ lâu

Streaming LLM trong Next.js: đổi route chat sang Server-Sent Events để chữ đầu tiên tới sau 818 ms thay vì 4 giây, kèm cách đọc luồng và ngắt khi khách rời đi.

Streaming LLM là cách server đẩy câu trả lời về trình duyệt theo từng mảnh ngay khi mô hình viết ra, thay vì đợi viết xong cả câu. Tổng thời gian gần như không đổi, nhưng khách thấy chữ đầu tiên sau chưa tới một giây. Trong Next.js, bạn dùng Route Handler trả ReadableStream. Cùng thử nhé!

Vì sao khách thấy chờ lâu dù mô hình không hề chậm hơn?

Ở bài trước, mình đã cắt hóa đơn của agent quán Mộc xuống còn khoảng một phần tư. (Quán Mộc là nhân vật minh họa của series này.) Nhưng có một thứ tiền không mua được: thời gian khách phải đợi. Nếu mô hình sinh khoảng 40 mảnh chữ mỗi giây, một câu trả lời dài vài trăm mảnh mất cả chục giây, và suốt chừng đó thời gian khung chat của khách trống trơn rồi bỗng hiện cả đoạn.

Mình nói trước một điều cho công bằng, giống mấy bài trước: bài này không gọi mô hình thật. Mình dùng một mô hình giả chờ 800 ms rồi nhả mỗi mảnh chữ sau 25 ms, và cả hai con số đó do mình tự đặt để dễ đo. Con số nên đọc là chênh lệch giữa hai cách làm. Đừng đọc chúng như tốc độ của một hãng nào. Đoạn gọi Claude thật nằm ở gần cuối bài, và mình chưa chạy nó.

Có một ý đáng nhớ trước khi viết code. Streaming không làm mô hình viết nhanh hơn, nó chỉ cho khách thấy những gì đã viết xong. Bạn sẽ thấy trong phần đo bên dưới rằng tổng thời gian của hai cách gần như bằng nhau.

Bản đầu tiên: đợi viết xong cả câu rồi mới trả

Trước hết mình dựng lại bản "chờ đủ câu", vì chỉ khi có số đo của nó thì mới biết streaming cải thiện được bao nhiêu. Bạn cần Node.js 22.18 trở lên. Tạo một thư mục moc-streaming rồi đặt các file theo cấu trúc này:

Cấu trúc thư mục
moc-streaming/
  package.json
  lib/
    mo-hinh-gia.js
    sse.js
  app/
    layout.js
    page.js
    khung-chat.js
    api/
      chat-cho-du/route.js
      chat/route.js
  do-thoi-gian.js

Mình viết bằng JavaScript thay vì TypeScript cho ví dụ gọn. Chạy npm install sau khi có package.json:

package.json
{
  "name": "moc-ai-agent-12",
  "private": true,
  "type": "module",
  "scripts": {
    "build": "next build",
    "start": "next start -p 3200"
  },
  "dependencies": {
    "@anthropic-ai/sdk": "1.5.0",
    "next": "16.4.4",
    "react": "19.3.1",
    "react-dom": "19.3.1"
  }
}

File đầu tiên là mô hình giả. Nó nhận tin nhắn của khách, chờ 800 ms như một mô hình đang "nghĩ", rồi nhả từng mảnh của một câu trả lời cố định, mỗi mảnh cách nhau 25 ms. Hàm hoiMoHinhGia là một async generator: mỗi lần yield là một mảnh chữ, đúng với cách các SDK của mô hình thật đưa chữ cho bạn.

lib/mo-hinh-gia.js
// Mô hình giả cho quán Mộc: không gọi mạng, không cần khóa API.
// Nó mô phỏng hai độ trễ của một mô hình thật: lúc "nghĩ" trước khi ra chữ đầu tiên, rồi nhả đều từng mảnh chữ.
// Con số là do mình đặt để dễ đo: 800 ms chờ chữ đầu, 25 ms mỗi mảnh (khoảng 40 mảnh mỗi giây).
export const CHO_CHU_DAU_MS = 800;
export const MOI_MANH_MS = 25;

export const CAU_TRA_LOI =
  "Dạ, quán Mộc giao hàng trong bán kính 5 km với phí 15.000đ, đơn từ 150.000đ thì miễn phí giao hàng. " +
  "Nếu quán giao sai món hoặc pha sai so với đơn, bạn nhắn cho quán trong vòng 30 phút kể từ lúc nhận, kèm ảnh món đã giao. " +
  "Quán sẽ pha lại món đúng và giao lại miễn phí, hoặc hoàn tiền nếu bạn không muốn đợi. " +
  "Tiền hoàn về đúng phương thức bạn đã thanh toán trong ba ngày làm việc. " +
  "Món đã uống quá một nửa thì quán không đổi được, nên bạn nhớ nhắn sớm nhé.";

// Tách câu trả lời thành các mảnh nhỏ (mỗi từ kèm dấu cách phía sau), giống cách mô hình nhả từng token.
export function tachManh(chu) {
  return chu.match(/\S+\s*/gu) ?? [];
}

const nghi = (ms) => new Promise((xong) => setTimeout(xong, ms));

// Trả về từng mảnh chữ, mỗi mảnh sau một khoảng chờ. `tin` chưa dùng trong bản giả: mọi câu hỏi nhận cùng một câu trả lời.
export async function* hoiMoHinhGia(tin, { tin_hieu } = {}) {
  await nghi(CHO_CHU_DAU_MS);
  for (const manh of tachManh(CAU_TRA_LOI)) {
    if (tin_hieu?.aborted) return;
    yield manh;
    await nghi(MOI_MANH_MS);
  }
}

Route cũ chỉ việc gom hết các mảnh lại thành một chuỗi, rồi trả về một cục JSON:

app/api/chat-cho-du/route.js
import { hoiMoHinhGia } from "../../../lib/mo-hinh-gia.js";

export const dynamic = "force-dynamic";

// POST /api/chat-cho-du: bản cũ. Đợi mô hình viết xong cả câu rồi mới trả một cục JSON.
export async function POST(request) {
  const { tin } = await request.json();
  let cauTraLoi = "";
  for await (const manh of hoiMoHinhGia(tin)) cauTraLoi += manh;
  return Response.json({ cauTraLoi });
}

Dòng export const dynamic = "force-dynamic" bảo Next.js chạy route này theo từng yêu cầu thay vì dựng sẵn lúc build. Với một route chat thì đó là điều bạn muốn.

SSE là gì, và route streaming trông thế nào?

Để đẩy từng mảnh về trình duyệt, bạn cần một định dạng cho các mảnh đó. Cách phổ biến nhất là Server-Sent Events (SSE): server giữ kết nối HTTP mở và gửi các "sự kiện" nối tiếp nhau. Mỗi sự kiện gồm vài dòng chữ, kết thúc bằng một dòng trống. Ví dụ một mảnh chữ "Dạ, " được gửi đi như sau:

Một sự kiện SSE
event: delta
data: {"text":"Dạ, "}

Dòng trống ở cuối là dấu hiệu "sự kiện này hết rồi". Mình bọc nội dung trong JSON để một mảnh chữ có xuống dòng hay dấu hai chấm cũng không làm hỏng định dạng. Hai hàm nhỏ trong lib/sse.js lo việc tạo sự kiện và đọc lại. Phần đọc mình giải thích kỹ ở dưới, còn bây giờ bạn chỉ cần hàm dongSuKien:

lib/sse.js
// Định dạng Server-Sent Events (SSE) mà route gửi đi, và bộ đọc phía người nhận.
// Một sự kiện SSE là vài dòng "tên: giá trị", kết thúc bằng MỘT DÒNG TRỐNG.
export function dongSuKien(ten, duLieu) {
  return `event: ${ten}\ndata: ${JSON.stringify(duLieu)}\n\n`;
}

// Bộ đọc nhận các mảnh chữ (chunk) theo đúng thứ tự mạng giao tới, và trả về các sự kiện đã đủ.
// Một chunk có thể chứa nhiều sự kiện, hoặc chỉ một nửa sự kiện, nên phần chưa đủ được giữ lại cho lần sau.
export class DocSse {
  #dem = "";

  push(chunk) {
    this.#dem += chunk;
    const cacSuKien = [];
    let vitri;
    while ((vitri = this.#dem.indexOf("\n\n")) !== -1) {
      const khoi = this.#dem.slice(0, vitri);
      this.#dem = this.#dem.slice(vitri + 2);
      const suKien = docKhoi(khoi);
      if (suKien) cacSuKien.push(suKien);
    }
    return cacSuKien;
  }
}

function docKhoi(khoi) {
  let ten = "message";
  const phanData = [];
  for (const dong of khoi.split("\n")) {
    if (dong.startsWith("event: ")) ten = dong.slice(7);
    else if (dong.startsWith("data: ")) phanData.push(dong.slice(6));
  }
  if (phanData.length === 0) return null;
  return { ten, duLieu: JSON.parse(phanData.join("\n")) };
}

Route streaming dùng ReadableStream, một chuẩn của trình duyệt mà Route Handler của Next.js dùng trực tiếp. Tài liệu về Route Handler có một mục riêng về streaming và nói rằng các lớp hỗ trợ đều xây trên các Web API này. Đây là phiên bản của mình:

app/api/chat/route.js
import { dongSuKien } from "../../../lib/sse.js";
import { hoiMoHinhGia } from "../../../lib/mo-hinh-gia.js";

// Chạy theo yêu cầu, không dựng sẵn lúc build.
export const dynamic = "force-dynamic";

const maHoa = new TextEncoder();

// POST /api/chat: trả câu trả lời theo từng mảnh bằng SSE. Chữ đầu tiên tới trình duyệt ngay khi mô hình ra chữ đầu tiên.
export async function POST(request) {
  const { tin } = await request.json();
  const dieuKhien = new AbortController();
  const nguon = hoiMoHinhGia(tin, { tin_hieu: dieuKhien.signal });
  let soManh = 0;

  const dong = new ReadableStream({
    // pull được gọi mỗi khi người nhận cần thêm dữ liệu: mỗi lần mình lấy một mảnh từ mô hình rồi đẩy đi.
    async pull(kenh) {
      const { value, done } = await nguon.next();
      if (done) {
        kenh.enqueue(maHoa.encode(dongSuKien("done", { soManh })));
        kenh.close();
        return;
      }
      soManh += 1;
      kenh.enqueue(maHoa.encode(dongSuKien("delta", { text: value })));
    },
    // cancel được gọi khi khách đóng tab hoặc ngắt kết nối: dừng hỏi mô hình để khỏi tốn tiền cho chữ không ai đọc.
    cancel() {
      dieuKhien.abort();
      console.log(`[chat] khách ngắt kết nối sau ${soManh} mảnh, đã dừng mô hình`);
    },
  });

  return new Response(dong, {
    headers: {
      "Content-Type": "text/event-stream; charset=utf-8",
      // no-transform: không cho proxy hay bộ nén gom chữ lại; X-Accel-Buffering: no dành cho nginx.
      "Cache-Control": "no-cache, no-transform",
      "X-Accel-Buffering": "no",
    },
  });
}

Có ba chỗ trong route này đáng nói. Hàm pull chỉ chạy khi bên nhận cần thêm dữ liệu, nên route không đọc trước cả đống chữ khi khách đọc chậm. Hàm cancel chạy khi khách ngắt kết nối, và chỗ đó mình báo cho mô hình dừng. Còn hai header ở cuối là để phòng chuyện proxy hay bộ nén gom chữ lại rồi mới gửi. Mình thử bỏ hai header này trong demo và chữ vẫn chạy ra bình thường, nên mình không tái hiện được lỗi gom chữ trên máy mình. Nhiều bài hướng dẫn nhắc rằng nginx hay một số lớp trung gian có thể làm vậy. Bạn chỉ cần để ý chuyện này khi triển khai thật mà thấy chữ hiện ra từng cục lớn thay vì từng mảnh.

Đo thử: chữ đầu tiên tới sau bao lâu?

Giờ so hai route. Script do-thoi-gian.js gửi cùng một câu hỏi tới cả hai, và đo hai thứ: thời gian tới khi có chunk đầu tiên có nội dung, và thời gian tới khi luồng kết thúc.

do-thoi-gian.js
// Đo hai điều khách cảm nhận được: bao lâu thì thấy chữ đầu tiên, và bao lâu thì có đủ câu trả lời.
// Chạy sau khi đã `npm run build` và `npm start` ở cổng 3200:  node do-thoi-gian.js
const GOC = "http://localhost:3200";
const dem = () => performance.now();

async function doDuong(duong) {
  const batDau = dem();
  const phanHoi = await fetch(`${GOC}${duong}`, { method: "POST", body: JSON.stringify({ tin: "Giao hàng thế nào?" }) });
  const boDoc = phanHoi.body.getReader();
  let chuDau = null;
  let soChunk = 0;
  for (;;) {
    const { value, done } = await boDoc.read();
    if (done) break;
    soChunk += 1;
    if (value.length > 0 && chuDau === null) chuDau = dem() - batDau;
  }
  const tong = dem() - batDau;
  return { duong, chuDau: Math.round(chuDau), tong: Math.round(tong), soChunk, loai: phanHoi.headers.get("content-type") };
}

for (const duong of ["/api/chat-cho-du", "/api/chat"]) {
  const kq = await doDuong(duong);
  console.log(`${kq.duong.padEnd(18)} chữ đầu sau ${String(kq.chuDau).padStart(4)} ms, đủ câu sau ${String(kq.tong).padStart(4)} ms, ${kq.soChunk} chunk (${kq.loai})`);
}

Chạy npm run build, npm start ở một terminal, rồi chạy script ở terminal khác (hai file layout.js và page.js mình để ở phần cuối bài, vì next build cần chúng):

node do-thoi-gian.js
/api/chat-cho-du   chữ đầu sau 4013 ms, đủ câu sau 4014 ms, 1 chunk (application/json)
/api/chat          chữ đầu sau  818 ms, đủ câu sau 3935 ms, 101 chunk (text/event-stream; charset=utf-8)

Hãy nhìn hai cột. Với bản cũ, khách đợi 4013 ms mới thấy một chữ nào, và cả câu tới trong một chunk duy nhất. Với bản streaming, chữ đầu tiên tới sau 818 ms (đúng bằng khoảng 800 ms "nghĩ" của mô hình giả cộng chút xíu) và câu hoàn tất sau 3935 ms, tức gần bằng bản cũ. Câu trả lời tới trong 101 chunk, gồm 100 mảnh chữ và một sự kiện kết thúc. Khách chờ phần đầu của câu ít hơn khoảng 5 lần, còn tổng thời gian thì mình không bớt được giây nào.

Con số quan trọng ở đây có một cái tên: thời gian tới token đầu tiên (time to first token). Nhiều bài hướng dẫn coi nó là chỉ số đáng theo dõi nhất của giao diện chat, và mình đồng ý, vì nó là khoảng lặng mà khách thật sự cảm nhận được.

Khách đóng tab giữa chừng thì sao?

Streaming mang theo một việc bản cũ không có: kết nối kéo dài vài giây, và khách có thể bỏ đi trong lúc đó. Nếu route cứ tiếp tục hỏi mô hình cho đủ câu, bạn trả tiền cho những chữ không ai đọc. Script thu-ngat.js mô phỏng chuyện này: nó đọc 10 chunk rồi ngắt kết nối.

thu-ngat.js
// Khách đóng tab giữa chừng: đọc vài mảnh rồi ngắt kết nối. Server phải dừng hỏi mô hình.
// Chạy khi máy chủ đang chạy ở cổng 3200:  node thu-ngat.js   rồi xem dòng "[chat] khách ngắt..." ở terminal của máy chủ.
const dieuKhien = new AbortController();
const phanHoi = await fetch("http://localhost:3200/api/chat", {
  method: "POST",
  body: JSON.stringify({ tin: "Giao hàng thế nào?" }),
  signal: dieuKhien.signal,
});
const boDoc = phanHoi.body.getReader();
let soChunk = 0;
while (soChunk < 10) {
  const { done } = await boDoc.read();
  if (done) break;
  soChunk += 1;
}
console.log(`đã nhận ${soChunk} chunk, ngắt kết nối`);
dieuKhien.abort();
await new Promise((xong) => setTimeout(xong, 500));
node thu-ngat.js (terminal của script)
đã nhận 10 chunk, ngắt kết nối
Terminal của máy chủ
[chat] khách ngắt kết nối sau 10 mảnh, đã dừng mô hình

Dòng thứ hai là hàm cancel của ReadableStream chạy đúng lúc khách ngắt. Nó báo cho AbortController, mô hình giả thấy tin_hieu.aborted và dừng, nên 90 mảnh còn lại không bao giờ được sinh ra. Với mô hình thật, SDK nhận cùng kiểu tín hiệu hủy, và đó là chỗ tiết kiệm tiền thật chứ không chỉ là gọn gàng.

Phía khách đọc luồng như thế nào?

Trình duyệt có sẵn EventSource để đọc SSE, nhưng nó chỉ gửi được yêu cầu GET, không gửi được nội dung tin nhắn. Vì chat cần POST, mình đọc luồng bằng fetch và ReadableStream của chính phản hồi. Đây là Client Component của khung chat. Phần quan trọng nằm trong vòng lặp for (;;):

app/khung-chat.js
"use client";

import { useRef, useState } from "react";

import { DocSse } from "../lib/sse.js";

// Khung chat: gửi tin tới /api/chat, đọc luồng SSE và nối từng mảnh vào câu trả lời đang hiện.
export function KhungChat() {
  const [tin, setTin] = useState("");
  const [cauTraLoi, setCauTraLoi] = useState("");
  const [dangNhan, setDangNhan] = useState(false);
  const dieuKhien = useRef(null);

  async function gui(suKienForm) {
    suKienForm.preventDefault();
    dieuKhien.current?.abort(); // khách gửi tin mới thì bỏ luồng cũ
    dieuKhien.current = new AbortController();
    setCauTraLoi("");
    setDangNhan(true);
    try {
      const phanHoi = await fetch("/api/chat", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ tin }),
        signal: dieuKhien.current.signal,
      });
      const boDoc = phanHoi.body.getReader();
      // stream: true để TextDecoder giữ lại byte của một ký tự bị cắt đôi giữa hai chunk.
      const giaiMa = new TextDecoder("utf-8");
      const docSse = new DocSse();
      for (;;) {
        const { value, done } = await boDoc.read();
        if (done) break;
        for (const suKien of docSse.push(giaiMa.decode(value, { stream: true }))) {
          if (suKien.ten === "delta") setCauTraLoi((truoc) => truoc + suKien.duLieu.text);
        }
      }
    } catch (loi) {
      if (loi.name !== "AbortError") setCauTraLoi("Xin lỗi, có lỗi xảy ra. Bạn thử lại giúp quán nhé.");
    } finally {
      setDangNhan(false);
    }
  }

  return (
    <form onSubmit={gui}>
      <label>
        Tin nhắn
        <input onChange={(e) => setTin(e.target.value)} value={tin} />
      </label>
      <button disabled={dangNhan} type="submit">
        Gửi
      </button>
      <p aria-live="polite">{cauTraLoi}</p>
    </form>
  );
}

Hai file còn lại để next build chạy được là khung trang và trang chủ:

app/layout.js
export default function RootLayout({ children }) {
  return (
    <html lang="vi">
      <body>{children}</body>
    </html>
  );
}
app/page.js
import { KhungChat } from "./khung-chat.js";

export default function Trang() {
  return (
    <main>
      <h1>Trợ lý quán Mộc</h1>
      <KhungChat />
    </main>
  );
}

Mình cần nói thật: mình chưa chạy khung chat này trong trình duyệt khi viết bài. Bản build chạy được và hai route đã đo ở trên, còn phần "chữ hiện dần trên màn hình" mình chỉ kiểm bằng những mảnh code mà nó dùng, tức DocSse và TextDecoder, qua các script và test trong thư mục demo. Bạn là người thử đầu tiên ở trình duyệt, và thẻ <p aria-live="polite"> ở cuối là để trình đọc màn hình đọc câu trả lời khi nó lớn dần.

Hai lỗi khi luồng bị cắt giữa chừng

Mạng không biết gì về sự kiện SSE của bạn. Nó chia luồng thành các chunk theo ý nó, và một chunk có thể kết thúc ở bất kỳ byte nào. Điều đó gây ra hai lỗi mà ví dụ trên mạng thường bỏ qua, và cả hai đều liên quan tới hai dòng giaiMa.decode(value, { stream: true }) và docSse.push(...) ở trên.

Lỗi thứ nhất là một chữ có dấu bị chia đôi. Chữ "ạ" trong "Dạ" chiếm 3 byte trong UTF-8, và nếu chunk dừng sau byte đầu tiên thì giải mã riêng từng chunk sẽ cho ra ký tự lỗi. Lỗi thứ hai là một sự kiện bị chia đôi: nếu bạn coi mỗi chunk là một sự kiện trọn vẹn thì đọc sẽ hỏng. Script này cố tình cắt luồng ở đúng những chỗ đó:

thu-chunk-bi-cat.js
// Hai lỗi hay gặp khi đọc luồng: (1) chunk cắt giữa một sự kiện, (2) chunk cắt giữa một chữ có dấu.
// Chạy: node thu-chunk-bi-cat.js   (không cần máy chủ)
import { DocSse, docNgayTho, dongSuKien } from "./lib/sse.js";

const maHoa = new TextEncoder();
const luong = dongSuKien("delta", { text: "Dạ, " }) + dongSuKien("delta", { text: "quán giao hàng " }) + dongSuKien("done", { soManh: 2 });
const byte = maHoa.encode(luong);

// Mạng có thể cắt luồng ở bất kỳ byte nào. Mình cắt ngay trong chữ "ạ" của "Dạ" (chữ này chiếm 3 byte).
const diem = byte.indexOf(0xe1) + 1; // sau byte đầu tiên của "ạ"
const chunk1 = byte.slice(0, diem);
const chunk2 = byte.slice(diem);
console.log(`Cắt luồng thành 2 chunk: ${chunk1.length} byte và ${chunk2.length} byte; chunk 1 dừng giữa chữ "ạ".\n`);

// Cách 1: giải mã mỗi chunk riêng, không giữ trạng thái.
const khongGiu = new TextDecoder();
const manhHong = khongGiu.decode(chunk1) + khongGiu.decode(chunk2);
console.log("Giải mã từng chunk riêng:", JSON.stringify(manhHong.slice(0, 45)));

// Cách 2: giải mã với { stream: true } để giữ lại byte còn dở.
const coGiu = new TextDecoder();
const manhDung = coGiu.decode(chunk1, { stream: true }) + coGiu.decode(chunk2, { stream: true });
console.log("Giải mã với stream: true:", JSON.stringify(manhDung.slice(0, 45)));

// Cách đọc sự kiện: coi mỗi chunk là sự kiện trọn vẹn thì sai khi chunk cắt giữa dòng.
const cacChunkChu = [manhDung.slice(0, 20), manhDung.slice(20)];
try {
  const ngayTho = cacChunkChu.flatMap((c) => docNgayTho(c));
  console.log("\nĐọc ngây thơ:", ngayTho.length, "sự kiện");
} catch (loi) {
  console.log("\nĐọc ngây thơ: lỗi", loi.name, "-", loi.message);
}
const docDung = new DocSse();
const suKien = cacChunkChu.flatMap((c) => docDung.push(c));
console.log("Dùng DocSse có bộ đệm:", suKien.length, "sự kiện:", suKien.map((s) => s.ten).join(", "));

Script này dùng thêm hàm docNgayTho, cách đọc "mỗi chunk là một sự kiện" mà mình để lại trong lib/sse.js chỉ để so sánh:

lib/sse.js (thêm hàm so sánh ở cuối file)
// Cách đọc "ngây thơ" để so sánh: coi mỗi chunk là một sự kiện trọn vẹn. Sẽ hỏng khi chunk cắt giữa chừng.
export function docNgayTho(chunk) {
  return chunk
    .split("\n\n")
    .filter(Boolean)
    .map((khoi) => docKhoi(khoi))
    .filter(Boolean);
}
node thu-chunk-bi-cat.js
Cắt luồng thành 2 chunk: 30 byte và 89 byte; chunk 1 dừng giữa chữ "ạ".

Giải mã từng chunk riêng: "event: delta\ndata: {\"text\":\"D���, \"}\n\nevent: "
Giải mã với stream: true: "event: delta\ndata: {\"text\":\"Dạ, \"}\n\nevent: de"

Đọc ngây thơ: lỗi SyntaxError - Expected property name or '}' in JSON at position 1 (line 1 column 2)
Dùng DocSse có bộ đệm: 3 sự kiện: delta, delta, done

Dòng thứ hai cho thấy "Dạ" thành "D" cộng ba ký tự lỗi, vì byte đầu của "ạ" nằm ở chunk 1 còn hai byte sau nằm ở chunk 2 và mỗi chunk bị giải mã như thể nó đứng một mình. Dòng thứ ba, với stream: true, TextDecoder giữ lại byte dở và chờ chunk sau, nên chữ về đúng. Dòng thứ tư cho thấy đọc ngây thơ nổ ngay ở lần cắt đầu tiên. Nó nhận nửa sự kiện, JSON.parse thấy một mảnh {"te và báo lỗi. DocSse giữ phần chưa đủ trong bộ đệm cho tới khi gặp dòng trống, nên cả ba sự kiện đều ra đúng.

Mình không muốn tin vào một lần cắt may rủi, nên có một test thử cắt luồng ở mọi vị trí byte. Bạn chạy bằng node --test lib/sse.test.js (file test nằm trong repo demo, mình không dán cả ở đây). Test lặp qua từng vị trí cắt của một luồng toàn chữ có dấu, và đòi chữ ghép lại luôn đúng. Cả chín test của tập này đều xanh.

Khi gọi mô hình thật thì khác gì?

Phần còn lại chỉ là thay nguồn chữ. Bản giả là một async generator, và với Claude thật bạn cũng viết một generator, chỉ khác là các mảnh chữ đến từ SDK. Tài liệu streaming của Anthropic mô tả: bạn đặt stream: true hoặc dùng hàm .stream() của SDK, và nhận các sự kiện qua SSE, trong đó các mảnh chữ nằm ở sự kiện content_block_delta có delta.type là text_delta. Đoạn dưới đây đặt vào lib/mo-hinh-that.js sẽ thay được hoiMoHinhGia. Mình chưa chạy nó, vì không có khóa API trong lúc viết bài, và các tên sự kiện mình lấy từ tài liệu của hãng:

lib/mo-hinh-that.js (chưa chạy)
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Cùng hình dạng với hoiMoHinhGia: nhận tin nhắn, trả về từng mảnh chữ, và dừng khi tin_hieu bị hủy.
export async function* hoiMoHinhThat(tin, { tin_hieu } = {}) {
  const luong = client.messages.stream(
    {
      model: "claude-opus-5-5",
      max_tokens: 16000,
      output_config: { effort: "low" },
      system: "Bạn là nhân viên chăm sóc khách hàng của quán cà phê Mộc. Trả lời ngắn gọn, thân thiện, bằng tiếng Việt.",
      messages: [{ role: "user", content: tin }],
    },
    { signal: tin_hieu },
  );
  for await (const suKien of luong) {
    if (suKien.type === "content_block_delta" && suKien.delta.type === "text_delta") yield suKien.delta.text;
  }
}

Nếu bạn đã đọc bài về tool calling thì sẽ thấy ngay một chỗ chưa khớp. Agent của Mộc không chỉ viết chữ, nó còn gọi công cụ giữa chừng để tra đơn, và mỗi lần gọi công cụ là một lượt gọi mô hình mới. Streaming chữ cho khách vẫn làm được, nhưng bạn phải quyết định cái gì hiện ra khi agent đang tra đơn. Một dòng như "Mộc đang kiểm tra đơn của bạn..." đẩy đi bằng một sự kiện SSE loại khác (ví dụ event: trang-thai) là cách đơn giản nhất, và DocSse ở trên đã đọc được mọi loại sự kiện, chỉ cần khung chat xử lý thêm một nhánh.

Chữ chạy ra nhanh rồi, nhưng có câu agent không nên tự trả lời

Khách của Mộc giờ thấy phản hồi ngay, và đó là cải thiện lớn nhất về cảm giác mà mình làm được ở mức hạ tầng. Nhưng chữ chạy ra nhanh lại làm lộ một chuyện khác. Nó chạy nhanh cả với những câu trả lời sai, và khi một khách đang bực vì món bị đổ, bị trễ hai giờ hay đòi hoàn tiền thì cả khung chat trôi đều đều một câu trả lời trơn tru cũng không giúp được gì. Có những tin agent không nên tự quyết, mà nên nhờ một người thật của quán nhìn vào. Cách chuyển cuộc trò chuyện cho người, và ghi lại để sau này tìm được nguyên nhân, là việc của các bài viết sau.

Bạn theo dõi cả hành trình ở Xây AI agent đầu tiên. Nếu muốn nhớ lại vì sao agent gọi mô hình nhiều lần cho một tin nhắn, hãy đọc vòng lặp AI agent. Các câu hỏi về AI agent nằm trong ngân hàng câu hỏi phỏng vấn.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.