Chi phí AI agent: cache prompt, model nhỏ và giới hạn lượt gọi

Giảm chi phí AI agent bằng cache prompt, model nhỏ cho tin đơn giản và giới hạn lượt gọi. Mô phỏng một ngày 200 tin nhắn của quán Mộc, tiền còn 28%.

Muốn giảm chi phí chạy AI agent, bạn cache phần prompt cố định, dùng model nhỏ cho tin đơn giản và đặt trần số lượt gọi cho mỗi tin. Trong mô phỏng một ngày 200 tin nhắn của quán Mộc, ba việc đó đưa hóa đơn xuống còn 28%. Cùng xem từng bước nhé.

Tiền của agent đi đâu mỗi khi khách nhắn một câu?

Ở bài trước, mình dựng bộ eval cho agent của quán Mộc và nhận ra một chuyện hơi khó chịu: một lần chạy 12 ca thử, mỗi ca 5 lần, là 85 lượt gọi mô hình. (Quán Mộc là nhân vật minh họa của series này.) Mười lần sửa trong tuần là 850 lượt, trong khi khách thật cũng đang nhắn cả ngày. Bài này trả lời câu hỏi: tiền đó đang đi đâu, và cắt chỗ nào thì không làm agent tệ đi?

Trước hết mình nói thẳng, giống hai bài trước: bài này không gọi mô hình thật. Số token trong demo là ước lượng (mình coi ba ký tự là một token, còn token thật do nhà cung cấp đếm và tiếng Việt thường tốn nhiều hơn), và bảng giá là giá giả định do mình đặt ra để so sánh. Con số có ý nghĩa là chênh lệch phần trăm giữa các cách làm, đừng đọc con số đô la như báo giá của hãng nào. Riêng các hệ số về cache thì mình lấy từ tài liệu chính thức của Anthropic, tra ngày 13/11/2026.

Cách mô hình tính tiền khá đơn giản: bạn trả theo số token gửi vào và số token nhận ra, và giá token ra thường đắt hơn token vào. Điều dễ bỏ sót là mô hình không có trí nhớ giữa các lượt gọi. Mỗi lượt, bạn phải gửi lại toàn bộ hướng dẫn, mô tả công cụ và thực đơn. Với agent của Mộc, phần cố định đó dài khoảng 630 token, còn tin nhắn của khách như "Đơn 1041 của em đâu rồi?" chỉ vài token. Gần như toàn bộ tiền đầu vào là trả cho những thứ không đổi từ tin này sang tin khác.

Tệ hơn, khi khách hỏi về đơn hàng, agent gọi mô hình hai lần: một lần để quyết định gọi công cụ xem_don, một lần để viết câu trả lời từ kết quả công cụ. Phần cố định bị gửi hai lần cho một tin nhắn.

Dựng một ngày của quán Mộc để có số đo

Để so các cách tiết kiệm công bằng với nhau, mình cần cùng một "ngày" làm đề thi. Bạn cần Node.js 22.18 trở lên (từ bản đó Node chạy thẳng file .ts). Tạo thư mục moc-chi-phi như sau:

Cấu trúc thư mục
moc-chi-phi/
  package.json
  chay.ts
  thu-gio-o-dau.ts
  thu-nho-cau-tra-loi.ts
  src/du-lieu.ts
  src/token.ts
  src/gia.ts
  src/chinh-sach.ts
  src/luu-dem.ts
  src/dinh-tuyen.ts
  src/bo-nho-tra-loi.ts
  src/mo-phong.ts
package.json
{
  "name": "moc-ai-agent-11",
  "private": true,
  "type": "module",
  "scripts": { "test": "node --test src" }
}

Ba file đầu rất ngắn. du-lieu.ts là ba đơn hàng minh họa (giống bài trước), token.ts là phép ước lượng thô, và gia.ts là bảng giá giả định cùng công thức tính tiền một lượt gọi. Trong công thức, phần tiền tố cố định có thể được tính theo bốn cách: giá thường, ghi cache 5 phút (1,25 lần), ghi cache 1 giờ (2 lần) hoặc đọc cache (0,1 lần).

src/du-lieu.ts
// Ba đơn hàng minh họa của quán Mộc; soDienThoai là của chủ đơn.
export const DON_HANG = [
  { maDon: "1041", soDienThoai: "0901000001", mon: ["cà phê sữa", "bánh mì trứng"], trangThai: "đang pha chế" },
  { maDon: "1042", soDienThoai: "0901000002", mon: ["bạc xỉu"], trangThai: "đang giao" },
  { maDon: "1043", soDienThoai: "0901000003", mon: ["cà phê muối"], trangThai: "đã giao" },
];

export const timDon = (maDon: string) => DON_HANG.find((don) => don.maDon === maDon);
src/token.ts
// Ước lượng số token của một đoạn văn. Chỉ là ước lượng thô (3 ký tự một token) để so sánh các cách làm với nhau;
// số token thật do mô hình bạn dùng đếm, và tiếng Việt thường tốn token hơn tiếng Anh.
export const uocTinhToken = (van: string): number => Math.ceil(van.length / 3);
src/gia.ts
// Bảng giá GIẢ ĐỊNH (đô la cho một triệu token) để so sánh. Không phải giá của hãng nào: giá thật xem ở trang giá của nhà cung cấp.
export type MoHinh = "lon" | "nho";
export const BANG_GIA: Record<MoHinh, { vao: number; ra: number }> = {
  lon: { vao: 3, ra: 15 },
  nho: { vao: 0.8, ra: 4 },
};

// Hệ số cache prompt, theo tài liệu của Anthropic (tra ngày 13/11/2026): ghi cache 5 phút = 1,25 lần giá vào,
// ghi cache 1 giờ = 2 lần, đọc cache = 0,1 lần (một số mô hình mới có hệ số đọc còn thấp hơn).
export const HE_SO = { ghi5Phut: 1.25, ghi1Gio: 2, doc: 0.1 };

export type LuotGoi = {
  moHinh: MoHinh;
  tokenVao: number; // tổng token đầu vào của lượt gọi
  tokenRa: number;
  cache: "doc" | "ghi5p" | "ghi1h" | "khong"; // phần "tiền tố" ổn định (tokenTienTo) được tính theo cách nào
  tokenTienTo: number;
};

export function tinhTien(luot: LuotGoi): number {
  const gia = BANG_GIA[luot.moHinh];
  const phanDoi = luot.tokenVao - luot.tokenTienTo; // phần thay đổi theo từng tin nhắn, luôn tính giá thường
  const heSoTienTo = luot.cache === "doc" ? HE_SO.doc : luot.cache === "ghi5p" ? HE_SO.ghi5Phut : luot.cache === "ghi1h" ? HE_SO.ghi1Gio : 1;
  const vao = (phanDoi + luot.tokenTienTo * heSoTienTo) * gia.vao;
  return (vao + luot.tokenRa * gia.ra) / 1_000_000;
}

Tiếp theo là phần cố định mà mọi lượt gọi đều gửi: mười hai quy tắc cho agent (kèm mô tả hai công cụ) và thực đơn mười bốn món. Bạn có thể thay bằng prompt của riêng bạn, miễn là dài hơn mức tối thiểu để được cache (mình nói kỹ ở mục sau).

src/chinh-sach.ts
// Phần đầu CỐ ĐỊNH của mọi lượt gọi: hướng dẫn cho agent, mô tả công cụ và thực đơn. Mọi khách, mọi tin nhắn đều gửi
// đúng phần này, nên đây là phần đáng để cache. (Nội dung minh họa của quán Mộc.)
const THUC_DON = [
  ["cà phê sữa", 29], ["cà phê đen", 25], ["bạc xỉu", 32], ["cà phê muối", 35], ["trà đào cam sả", 39],
  ["trà vải", 37], ["matcha latte", 45], ["sinh tố bơ", 42], ["nước cam ép", 35], ["bánh mì trứng", 25],
  ["bánh mì thịt nguội", 30], ["bánh flan", 20], ["bánh su kem", 22], ["croissant bơ", 28],
] as const;

export const HUONG_DAN = [
  'Bạn là trợ lý chăm sóc khách hàng của quán cà phê Mộc. Luôn xưng "em", gọi khách là "mình", trả lời ngắn gọn bằng tiếng Việt.',
  "Chỉ hỗ trợ về đơn hàng và thực đơn của quán. Với câu hỏi khác (viết code, thời tiết, tin tức), lịch sự từ chối và nói em chỉ hỗ trợ đơn hàng và thực đơn.",
  "Khi khách hỏi về một đơn hàng, luôn gọi công cụ xem_don với mã đơn khách nêu. Không được đoán trạng thái đơn khi chưa tra.",
  "Không bao giờ hứa hoàn tiền, đền tiền hay giảm giá. Mọi yêu cầu về tiền phải chuyển cho chủ quán xử lý.",
  "Không tiết lộ thông tin của khách khác: số điện thoại, địa chỉ, món trong đơn của người khác. Công cụ xem_don chỉ trả đơn của chính khách đang nhắn.",
  "Quán mở cửa từ 7 giờ đến 21 giờ mỗi ngày, kể cả cuối tuần. Giao hàng trong bán kính 5 km, phí giao hàng 15.000đ, miễn phí cho đơn từ 150.000đ.",
  "Đơn đặt trước 16 giờ được giao trong ngày. Đơn đặt sau 16 giờ được giao vào sáng hôm sau, bắt đầu từ 8 giờ.",
  'Nếu khách muốn đổi hoặc hủy đơn: đơn đang ở trạng thái "đang pha chế" hoặc "đang giao" không hủy được, hãy chuyển cho chủ quán.',
  "Không tự bịa món hoặc giá không có trong thực đơn bên dưới. Món hết hàng thì xin lỗi và gợi ý món gần giống trong thực đơn.",
  "Khách tỏ ra bực bội hoặc nhắn lặp lại ba lần mà chưa được giải quyết thì chuyển cho chủ quán và nói rõ quán sẽ liên hệ lại.",
  "Công cụ xem_don(maDon): nhận mã đơn gồm 4 chữ số, trả về trạng thái, danh sách món và thời gian dự kiến của đơn thuộc về khách đang nhắn.",
  "Công cụ chuyen_cho_nguoi(lyDo): chuyển cuộc trò chuyện cho chủ quán kèm lý do ngắn, dùng cho hoàn tiền, khiếu nại, đổi hoặc hủy đơn.",
].join("\n");

export const MENU = THUC_DON.map(([ten, gia]) => `- ${ten}: ${gia}.000đ`).join("\n");
export const TIEN_TO = `${HUONG_DAN}\n\nThực đơn:\n${MENU}`;

File này có 1.887 ký tự, tức khoảng 629 token theo cách ước lượng của mình. Nhớ con số 629, nó quyết định nhiều chuyện ở mục sau.

Cache prompt: trả một lần, đọc nhiều lần

Cache prompt nghĩa là nhà cung cấp nhớ giúp bạn phần đầu của prompt đã xử lý, lần sau chỉ tính một phần nhỏ giá để đọc lại. Theo tài liệu prompt caching của Anthropic, có bốn điều bạn cần biết trước khi tính toán.

Một, ghi vào cache đắt hơn giá thường (1,25 lần với cache 5 phút, 2 lần với cache 1 giờ), còn đọc từ cache chỉ bằng 0,1 lần giá đầu vào (với một số mô hình mới, hệ số này còn thấp hơn). Hai, cache sống 5 phút theo mặc định và được làm mới miễn phí mỗi lần có người dùng tới nó, hoặc bạn trả thêm để chọn 1 giờ bằng ttl: "1h". Ba, cache được dựng theo thứ tự công cụ, rồi system prompt, rồi tin nhắn, và chỉ khớp khi phần đầu giống hệt từng ký tự; đổi một chữ ở phần đầu thì phần sau cũng mất cache. Bốn, prompt ngắn hơn mức tối thiểu thì không được cache, và tài liệu nói rõ là không có lỗi nào báo cho bạn biết. Mức tối thiểu tùy mô hình, từ 512 token ở các mô hình mới nhất tới 4.096 token ở một số mô hình cũ, nên bạn phải tra bảng của đúng mô hình bạn dùng.

Mình viết một bộ nhớ cache giả để mô phỏng bốn điều đó. Nó nhận một khóa (mô hình cộng tiền tố), số token của tiền tố và thời điểm, rồi trả về "đọc", "ghi" hoặc "không được cache":

src/luu-dem.ts
// Mô phỏng cache prompt theo mô tả trong tài liệu của Anthropic: cache chỉ khớp khi TIỀN TỐ giống hệt từng ký tự,
// sống 5 phút (hoặc 1 giờ nếu chọn) và được làm mới mỗi lần dùng, và không áp dụng khi tiền tố ngắn hơn mức tối thiểu.
export type KetQuaCache = "doc" | "ghi" | "khong";

export class BoNhoDem {
  private hetHan = new Map<string, number>(); // khóa = mô hình + tiền tố; giá trị = giây hết hạn
  private ttlGiay: number;
  private toiThieuToken: number;
  constructor(ttlGiay: number, toiThieuToken = 512) {
    this.ttlGiay = ttlGiay;
    this.toiThieuToken = toiThieuToken;
  }

  dung(khoa: string, soTokenTienTo: number, giay: number): KetQuaCache {
    if (soTokenTienTo < this.toiThieuToken) return "khong"; // quá ngắn: không cache, cũng không báo lỗi
    const han = this.hetHan.get(khoa);
    this.hetHan.set(khoa, giay + this.ttlGiay); // đọc hay ghi đều làm mới thời hạn
    return han !== undefined && han >= giay ? "doc" : "ghi";
  }
}

Giờ đến "đề thi": file mo-phong.ts sinh ra 200 tin nhắn của 60 khách rải trong ngày (nhiều nhất là khoảng 11 đến 13 giờ), rồi tính tiền theo một cách vận hành cho trước. Trong 200 tin có 45% hỏi đơn, 20% hỏi thực đơn, 15% hỏi giờ mở cửa, 10% đòi hoàn tiền và 10% hỏi ngoài phạm vi. Mình cũng cài sẵn một lỗi có thật ở agent: cứ 50 tin thì có một tin làm agent gọi lại cùng một công cụ mãi (12 lượt), giống chuyện vòng lặp agent chạy không dừng. Chưa dùng đến nó ở mục này, nhưng nó sẽ quan trọng ở mục cuối.

Cùng thời điểm, file này cũng nhận các tùy chọn dinhTuyen, toiDaLuot và gioODau, mình sẽ giải thích từng cái ở các mục sau. Bạn cứ chép nguyên file vào trước:

src/mo-phong.ts
// Mô phỏng một ngày của quán Mộc: 200 tin nhắn của 60 khách, rồi tính tiền theo từng cách vận hành.
// Không gọi mô hình thật: số token là ước lượng, bảng giá là giả định. Cái cần xem là CHÊNH LỆCH giữa các cách làm.
import { chonMoHinh } from "./dinh-tuyen.ts";
import { type LuotGoi, tinhTien, type MoHinh } from "./gia.ts";
import { TIEN_TO } from "./chinh-sach.ts";
import { BoNhoDem } from "./luu-dem.ts";
import { uocTinhToken } from "./token.ts";

export type Loai = "tra-don" | "thuc-don" | "gio-mo-cua" | "hoan-tien" | "ngoai-pham-vi";
export type YeuCau = { giay: number; khach: string; loai: Loai; tin: string };

const TIN: Record<Loai, string[]> = {
  "tra-don": ["Đơn 1041 của em đâu rồi?", "Đơn 1042 khi nào tới vậy quán?", "Đơn 1043 đã giao chưa?"],
  "thuc-don": ["Quán có những món gì?", "Quán có món gì uống với bánh không?"],
  "gio-mo-cua": ["Quán mấy giờ đóng cửa vậy?", "Giờ mở cửa của quán thế nào?"],
  "hoan-tien": ["Em muốn hoàn tiền đơn 1041.", "Giao trễ quá, quán đền tiền cho em đi."],
  "ngoai-pham-vi": ["Hôm nay Hà Nội có mưa không?", "Viết giúp em một hàm sắp xếp mảng."],
};
const TRONG_SO: [Loai, number][] = [["tra-don", 45], ["thuc-don", 20], ["gio-mo-cua", 15], ["hoan-tien", 10], ["ngoai-pham-vi", 10]];
// Số token đầu ra của từng lượt gọi mô hình cho mỗi loại tin (ước lượng). "tra-don" có hai lượt: gọi công cụ, rồi trả lời.
const TOKEN_RA: Record<Loai, number[]> = { "tra-don": [30, 70], "thuc-don": [90], "gio-mo-cua": [45], "hoan-tien": [60], "ngoai-pham-vi": [40] };

function sinhSo(hat: number): () => number {
  let a = hat;
  return () => {
    a = (a + 0x6d2b79f5) | 0;
    let t = Math.imul(a ^ (a >>> 15), 1 | a);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

// Giờ cao điểm: sáng, trưa, chiều, tối. Mỗi phần tử là [giờ bắt đầu, giờ kết thúc, trọng số].
const KHUNG_GIO = [[7, 9, 3], [11, 13, 5], [15, 17, 2], [19, 21, 1]];

export function sinhLuuLuong(soYeuCau = 200, hat = 2026): YeuCau[] {
  const ngauNhien = sinhSo(hat);
  const tongKhung = KHUNG_GIO.reduce((t, k) => t + k[2], 0);
  const ds: YeuCau[] = [];
  for (let i = 0; i < soYeuCau; i++) {
    let r = ngauNhien() * tongKhung;
    const khung = KHUNG_GIO.find((k) => (r -= k[2]) < 0) ?? KHUNG_GIO[0];
    const giay = Math.floor((khung[0] + ngauNhien() * (khung[1] - khung[0])) * 3600);
    let p = ngauNhien() * 100;
    const loai = TRONG_SO.find(([, w]) => (p -= w) < 0)?.[0] ?? "tra-don";
    const cacTin = TIN[loai];
    const khach = `09010000${String(1 + Math.floor(ngauNhien() * 60)).padStart(2, "0")}`;
    ds.push({ giay, khach, loai, tin: cacTin[Math.floor(ngauNhien() * cacTin.length)] });
  }
  return ds.sort((a, b) => a.giay - b.giay);
}

export type CachVanHanh = {
  cache: "khong" | "5p" | "1h";
  dinhTuyen: boolean;
  /** Số lượt gọi mô hình tối đa cho một tin nhắn. Chưa đặt thì tin "lặp công cụ" chạy hết 12 lượt. */
  toiDaLuot?: number;
  /** Lỗi hay gặp: đặt giờ hiện tại ở ĐẦU hướng dẫn, làm tiền tố khác nhau ở mỗi lượt gọi và phá cache. */
  gioODau?: boolean;
};
export type KetQua = { tien: number; soLuotGoi: number; doc: number; ghi: number; khong: number; chuyenNguoi: number };

const LUOT_LAP = 12; // một tin nhắn làm agent gọi lại cùng một công cụ mãi (mô phỏng lỗi vòng lặp)

export function chayNgay(luuLuong: YeuCau[], cach: CachVanHanh): KetQua {
  const ttl = cach.cache === "1h" ? 3600 : 300;
  const bo: Record<MoHinh, BoNhoDem> = { lon: new BoNhoDem(ttl), nho: new BoNhoDem(ttl) };
  const kq: KetQua = { tien: 0, soLuotGoi: 0, doc: 0, ghi: 0, khong: 0, chuyenNguoi: 0 };
  luuLuong.forEach((yc, i) => {
    const moHinh: MoHinh = cach.dinhTuyen ? chonMoHinh(yc.tin) : "lon";
    const biLap = i % 50 === 7; // 4 trong 200 tin làm agent lặp công cụ
    const tokenRa = biLap ? Array<number>(LUOT_LAP).fill(30) : TOKEN_RA[yc.loai];
    const toiDa = cach.toiDaLuot ?? Infinity;
    const soLuot = Math.min(tokenRa.length, toiDa);
    if (tokenRa.length > toiDa) kq.chuyenNguoi++;
    let phanDoi = uocTinhToken(yc.tin); // phần đổi theo tin nhắn; mỗi lượt sau cộng thêm ~80 token kết quả công cụ
    for (let l = 0; l < soLuot; l++) {
      const gio = cach.gioODau ? `Bây giờ là ${new Date((yc.giay + l) * 1000).toISOString().slice(11, 19)}.\n` : "";
      const tienTo = gio + TIEN_TO;
      const tokenTienTo = uocTinhToken(tienTo);
      const luot: LuotGoi = { moHinh, tokenVao: tokenTienTo + phanDoi, tokenRa: tokenRa[l], tokenTienTo, cache: "khong" };
      if (cach.cache !== "khong") {
        const ketQuaCache = bo[moHinh].dung(`${moHinh}|${tienTo}`, tokenTienTo, yc.giay + l);
        luot.cache = ketQuaCache === "doc" ? "doc" : ketQuaCache === "ghi" ? (cach.cache === "1h" ? "ghi1h" : "ghi5p") : "khong";
        kq[ketQuaCache]++;
      }
      kq.tien += tinhTien(luot);
      kq.soLuotGoi++;
      phanDoi += 80;
    }
  });
  return kq;
}

File mo-phong.ts import src/dinh-tuyen.ts, mình viết ở mục sau. Bạn tạo trước file đó (nội dung ở dưới) rồi hãy chạy thử, nếu không Node sẽ báo thiếu module.

Chọn model nhỏ cho tin đơn giản, và đừng để nó chọn sai

Ý tưởng thứ hai dễ hiểu hơn: một câu như "Quán mấy giờ đóng cửa vậy?" không cần mô hình lớn nhất. Nhiều nhà cung cấp bán cùng lúc mô hình lớn và mô hình nhỏ, giá chênh nhau nhiều lần. Trong bảng giá giả định của mình, mô hình nhỏ chỉ bằng khoảng một phần tư giá mô hình lớn.

Vấn đề là ai quyết định tin nào "đơn giản"? Mình thấy hai cách làm đầu tiên đều hấp dẫn và đều có lỗ hổng. Chọn theo độ dài tin nhắn thì sai ngay: "Hoàn 500k đơn 1041" rất ngắn nhưng là tin nhạy cảm nhất trong ngày. Hỏi một mô hình khác để phân loại thì lại tốn thêm một lượt gọi cho mỗi tin, và lỗi phân loại thì rơi đúng vào các tin quan trọng.

Cách mình chọn cho Mộc là luật bằng code, với một nguyên tắc: mặc định là mô hình lớn, chỉ những tin chắc chắn đơn giản mới được đi đường tắt. Một tin là "câu hỏi chung" khi khớp với mẫu về thực đơn hoặc giờ mở cửa, và không chứa gì dính tới đơn hay tiền (số bốn chữ số, "hoàn", "đền", "hủy", "tiền", "bực"...).

src/dinh-tuyen.ts
// Chọn mô hình theo nội dung tin nhắn, bằng code. Mặc định là mô hình lớn; chỉ đưa sang mô hình nhỏ những tin
// chắc chắn là câu hỏi đơn giản (thực đơn, giờ mở cửa) và không dính tới đơn hàng hay tiền.
import type { MoHinh } from "./gia.ts";

const DON_GIAN = /(thực đơn|món gì|có món|giờ mở cửa|mấy giờ (mở|đóng)|phí giao|giao.*bao xa)/iu;
const NHAY_CAM = /(\d{4}|hoàn|đền|trả lại|hủy|đổi|tiền|bực|khiếu nại|người đặt|số điện thoại)/iu;

/** Câu hỏi chung: câu trả lời giống nhau với mọi khách (thực đơn, giờ mở cửa), không dính tới đơn hay tiền. */
export const laCauHoiChung = (tin: string): boolean => DON_GIAN.test(tin) && !NHAY_CAM.test(tin);

export const chonMoHinh = (tin: string): MoHinh => (laCauHoiChung(tin) ? "nho" : "lon");

Cái giá của sự thận trọng này là tin "Hôm nay Hà Nội có mưa không?" cũng đi mô hình lớn, vì nó không khớp mẫu nào. Mình chấp nhận: bỏ sót một cơ hội tiết kiệm thì mất vài xu, còn đẩy nhầm một tin hoàn tiền sang mô hình nhỏ thì có thể mất cả đơn hàng. Và vì mô hình nhỏ hay lệch hơn, hãy chạy đúng bộ eval ở bài trước lên mô hình nhỏ cho những ca nó được giao. Trong 12 ca của bộ eval đó, chỉ ca "hỏi thực đơn" đi qua đường tắt này.

Chạy cả ngày và nhìn từng bước tiết kiệm

Giờ gom lại. Script chay.ts chạy cùng một ngày qua năm cách vận hành, từ chưa tối ưu tới đủ ba lớp, và in tiền cùng số lượt gọi:

chay.ts
// So sánh chi phí một ngày của quán Mộc qua từng cách vận hành. Chạy: node chay.ts
import { TIEN_TO } from "./src/chinh-sach.ts";
import { chayNgay, sinhLuuLuong, type CachVanHanh } from "./src/mo-phong.ts";
import { uocTinhToken } from "./src/token.ts";

const luuLuong = sinhLuuLuong(200);
console.log(`Phần hướng dẫn cố định: ${TIEN_TO.length} ký tự, khoảng ${uocTinhToken(TIEN_TO)} token. ${luuLuong.length} tin nhắn trong ngày.\n`);

const CAC_CACH: [string, CachVanHanh][] = [
  ["0. Chưa tối ưu", { cache: "khong", dinhTuyen: false }],
  ["1. Bật cache 5 phút", { cache: "5p", dinhTuyen: false }],
  ["2. Đổi sang cache 1 giờ", { cache: "1h", dinhTuyen: false }],
  ["3. Cache 1 giờ + mô hình nhỏ cho tin đơn giản", { cache: "1h", dinhTuyen: true }],
  ["4. Thêm giới hạn 4 lượt gọi mỗi tin nhắn", { cache: "1h", dinhTuyen: true, toiDaLuot: 4 }],
];
const goc = chayNgay(luuLuong, CAC_CACH[0][1]).tien;
for (const [ten, cach] of CAC_CACH) {
  const kq = chayNgay(luuLuong, cach);
  const cacheTxt = cach.cache === "khong" ? "" : `, cache đọc ${kq.doc}/ghi ${kq.ghi}`;
  const nguoiTxt = cach.toiDaLuot ? `, ${kq.chuyenNguoi} tin chuyển cho người` : "";
  console.log(`${ten}\n   ${kq.tien.toFixed(4)} $ (${Math.round((kq.tien / goc) * 100)}% so với gốc), ${kq.soLuotGoi} lượt gọi${cacheTxt}${nguoiTxt}`);
}
Chạy so sánh
node chay.ts
Kết quả
Phần hướng dẫn cố định: 1887 ký tự, khoảng 629 token. 200 tin nhắn trong ngày.

0. Chưa tối ưu
   0.9605 $ (100% so với gốc), 327 lượt gọi
1. Bật cache 5 phút
   0.4637 $ (48% so với gốc), 327 lượt gọi, cache đọc 300/ghi 27
2. Đổi sang cache 1 giờ
   0.4195 $ (44% so với gốc), 327 lượt gọi, cache đọc 323/ghi 4
3. Cache 1 giờ + mô hình nhỏ cho tin đơn giản
   0.2872 $ (30% so với gốc), 327 lượt gọi, cache đọc 319/ghi 8
4. Thêm giới hạn 4 lượt gọi mỗi tin nhắn
   0.2661 $ (28% so với gốc), 295 lượt gọi, cache đọc 287/ghi 8, 4 tin chuyển cho người

Hãy nhìn phần trăm ở cột giữa. Cache 5 phút một mình đã cắt hơn nửa hóa đơn, vì 300 trong 327 lượt gọi được đọc từ cache với giá bằng một phần mười. Đổi sang cache 1 giờ giảm thêm một chút: cache 5 phút phải ghi lại 27 lần (mỗi lần ghi đắt 1,25 lần giá thường) vì có những quãng vắng khách dài hơn 5 phút, còn cache 1 giờ chỉ ghi 4 lần dù mỗi lần ghi đắt hơn (2 lần). Với quán nhỏ có giờ vắng, cache dài đáng đồng tiền. Với agent có khách nhắn liên tục, cache 5 phút là đủ, vì mỗi lần đọc làm mới thời hạn.

Mô hình nhỏ giảm tiếp từ 44% xuống 30%. Số lần ghi cache tăng từ 4 lên 8, vì giờ có hai mô hình, mỗi mô hình có phần cố định riêng của nó phải ghi. Đây là một tác dụng phụ đáng nhớ: chia lưu lượng cho nhiều mô hình thì mỗi cache nhận ít lượt đọc hơn.

Bước cuối, giới hạn lượt gọi, mình để lại cho mục sau vì nó cần cẩn thận hơn.

Hai cách tiết kiệm nghe hợp lý nhưng làm hỏng agent

Mình thử những cách "tối ưu" mà người ta hay nghĩ ra trước khi đọc kỹ tài liệu, và hai cách thất bại rất đáng nhớ.

Lỗi đầu tiên là đặt giờ hiện tại vào đầu hướng dẫn, kiểu "Bây giờ là 11:42:07". Rất nhiều người làm vậy vì muốn agent biết giờ để trả lời "quán còn mở không". Nhưng cache chỉ khớp khi tiền tố giống hệt từng ký tự, mà giờ thì khác nhau ở mọi lượt gọi. Script sau chạy cùng ngày, cùng cache 5 phút, chỉ khác chỗ đặt giờ:

thu-gio-o-dau.ts
// Lỗi hay gặp: đặt giờ hiện tại ở ĐẦU hướng dẫn. Chạy: node thu-gio-o-dau.ts
import { chayNgay, sinhLuuLuong } from "./src/mo-phong.ts";

const luuLuong = sinhLuuLuong(200);
for (const [ten, gioODau] of [["giờ để sau phần cố định (đúng)", false], ["giờ ở đầu hướng dẫn (sai)", true]] as const) {
  const kq = chayNgay(luuLuong, { cache: "5p", dinhTuyen: false, gioODau });
  console.log(`${ten.padEnd(32)} cache đọc ${String(kq.doc).padStart(3)}, ghi ${String(kq.ghi).padStart(3)}, tiền ${kq.tien.toFixed(4)} $`);
}
Chạy thử
node thu-gio-o-dau.ts
Kết quả
giờ để sau phần cố định (đúng)   cache đọc 300, ghi  27, tiền 0.4637 $
giờ ở đầu hướng dẫn (sai)        cache đọc   1, ghi 326, tiền 1.1211 $

Dòng thứ hai là điều đau nhất: chỉ có 1 lần đọc cache trên 327 lượt, trong khi 326 lần bạn trả giá ghi đắt hơn bình thường. Tiền là 1,12 đô la, đắt hơn cả lúc chưa bật cache (0,96 đô la). Bật một tính năng tiết kiệm mà đắt hơn trước là kết quả khá khó tin nếu bạn chỉ nhìn thấy giao diện thanh toán cuối tháng. Cách sửa là đặt những thứ đổi liên tục (giờ, tên khách, mã đơn) sau phần cố định, tức là vào tin nhắn, không phải vào hướng dẫn. Nên nhớ cả danh sách công cụ cũng nằm trong tiền tố (nó đứng đầu tiên), nên thêm hay sửa một công cụ cũng làm mất cache.

Lỗi thứ hai tinh vi hơn, và nguy hiểm hơn tiền. Có người nghĩ: "Cache câu trả lời luôn đi, khỏi gọi mô hình!" Nghe hợp lý: 200 tin mỗi ngày chắc có nhiều tin giống hệt nhau. Mình viết thử cách đó, nhớ câu trả lời theo nội dung tin nhắn, cạnh một cách khác chỉ nhớ "câu hỏi chung":

src/bo-nho-tra-loi.ts
// Nhớ câu trả lời để khỏi gọi mô hình lần nữa. Có hai cách làm: cách đầu (sai) nhớ theo nội dung tin nhắn cho MỌI tin,
// cách đúng chỉ nhớ câu hỏi chung, tức câu trả lời giống nhau với mọi khách.
import { timDon } from "./du-lieu.ts";
import { laCauHoiChung } from "./dinh-tuyen.ts";

// Một "agent" rất nhỏ để thử: trả lời câu hỏi chung, hoặc đọc đơn gần nhất của chính khách đang nhắn.
export function traLoiThat(soDienThoai: string, tin: string, ghiSoLan: () => void): string {
  ghiSoLan(); // mỗi lần vào đây là một lượt gọi mô hình thật
  if (/đơn.*(gần nhất|của em)/iu.test(tin)) {
    const don = ["1041", "1042", "1043"].map((ma) => timDon(ma)).find((d) => d?.soDienThoai === soDienThoai);
    return don ? `Dạ đơn ${don.maDon} của mình ${don.trangThai}, gồm ${don.mon.join(", ")} ạ.` : "Dạ em chưa thấy đơn nào của mình ạ.";
  }
  if (/giờ/iu.test(tin)) return "Dạ quán mở cửa từ 7 giờ đến 21 giờ mỗi ngày ạ.";
  return "Dạ em chỉ hỗ trợ về đơn hàng và thực đơn của quán Mộc thôi ạ.";
}

const chuanHoa = (tin: string) => tin.trim().toLowerCase().replace(/\s+/g, " ");

/** Cách SAI: nhớ theo nội dung tin nhắn, bất kể câu trả lời có phụ thuộc vào khách hay không. */
export class NhoTheoTin {
  private nho = new Map<string, string>();
  hoi(soDienThoai: string, tin: string, goiMoHinh: () => void): string {
    const khoa = chuanHoa(tin);
    const co = this.nho.get(khoa);
    if (co !== undefined) return co;
    const traLoi = traLoiThat(soDienThoai, tin, goiMoHinh);
    this.nho.set(khoa, traLoi);
    return traLoi;
  }
}

/** Cách ĐÚNG: chỉ nhớ câu hỏi chung, và câu trả lời hết hạn sau `ttlGiay` để khi đổi thực đơn không bị cũ mãi. */
export class NhoCauHoiChung {
  private nho = new Map<string, { traLoi: string; hetHan: number }>();
  private ttlGiay: number;
  constructor(ttlGiay = 3600) {
    this.ttlGiay = ttlGiay;
  }
  hoi(soDienThoai: string, tin: string, giay: number, goiMoHinh: () => void): string {
    if (!laCauHoiChung(tin)) return traLoiThat(soDienThoai, tin, goiMoHinh); // câu riêng của khách: không bao giờ nhớ
    const khoa = chuanHoa(tin);
    const co = this.nho.get(khoa);
    if (co && co.hetHan > giay) return co.traLoi;
    const traLoi = traLoiThat(soDienThoai, tin, goiMoHinh);
    this.nho.set(khoa, { traLoi, hetHan: giay + this.ttlGiay });
    return traLoi;
  }
}

Rồi cho hai khách khác nhau hỏi đúng cùng một câu "Đơn của em đâu rồi?":

thu-nho-cau-tra-loi.ts
// Nhớ câu trả lời để khỏi gọi mô hình: cách sai (theo nội dung tin) và cách đúng (chỉ câu hỏi chung). Chạy: node thu-nho-cau-tra-loi.ts
import { NhoCauHoiChung, NhoTheoTin } from "./src/bo-nho-tra-loi.ts";

const hoi = "Đơn của em đâu rồi?";
let luot = 0;
const dem = () => luot++;

console.log("Cách sai: nhớ theo nội dung tin nhắn");
const sai = new NhoTheoTin();
console.log(`  Khách 0901000002 hỏi "${hoi}" -> ${sai.hoi("0901000002", hoi, dem)}`);
console.log(`  Khách 0901000003 hỏi "${hoi}" -> ${sai.hoi("0901000003", hoi, dem)}  (${luot} lượt gọi mô hình)`);

luot = 0;
console.log("Cách đúng: chỉ nhớ câu hỏi chung");
const dung = new NhoCauHoiChung();
console.log(`  Khách 0901000002 hỏi "${hoi}" -> ${dung.hoi("0901000002", hoi, 0, dem)}`);
console.log(`  Khách 0901000003 hỏi "${hoi}" -> ${dung.hoi("0901000003", hoi, 1, dem)}`);
const gio = "Quán mấy giờ đóng cửa vậy?";
const truoc = luot;
for (let i = 0; i < 3; i++) dung.hoi(`09010000${10 + i}`, gio, 10 + i, dem);
console.log(`  Ba khách khác hỏi "${gio}" -> ${luot - truoc} lượt gọi mô hình (câu hỏi chung chỉ gọi một lần)`);
Chạy thử
node thu-nho-cau-tra-loi.ts
Kết quả
Cách sai: nhớ theo nội dung tin nhắn
  Khách 0901000002 hỏi "Đơn của em đâu rồi?" -> Dạ đơn 1042 của mình đang giao, gồm bạc xỉu ạ.
  Khách 0901000003 hỏi "Đơn của em đâu rồi?" -> Dạ đơn 1042 của mình đang giao, gồm bạc xỉu ạ.  (1 lượt gọi mô hình)
Cách đúng: chỉ nhớ câu hỏi chung
  Khách 0901000002 hỏi "Đơn của em đâu rồi?" -> Dạ đơn 1042 của mình đang giao, gồm bạc xỉu ạ.
  Khách 0901000003 hỏi "Đơn của em đâu rồi?" -> Dạ đơn 1043 của mình đã giao, gồm cà phê muối ạ.
  Ba khách khác hỏi "Quán mấy giờ đóng cửa vậy?" -> 1 lượt gọi mô hình (câu hỏi chung chỉ gọi một lần)

Hai dòng đầu là chỗ cần nhìn. Khách 0901000003 hỏi cùng một câu, và nhận về đơn bạc xỉu của khách 0901000002, tức là tên món và trạng thái đơn của người khác. Lỗi này không làm hóa đơn tăng, nó làm lộ dữ liệu, mà lại rất khó thấy vì mọi thứ đều "nhanh và rẻ". Cách đúng cho Mộc chỉ nhớ câu hỏi chung (cùng bộ lọc đã dùng để chọn mô hình nhỏ), nên tin về đơn luôn đi qua mô hình và công cụ, và công cụ kiểm tra chủ đơn như đã làm ở các bài trước. Câu trả lời được nhớ cũng nên hết hạn, ở đây là một giờ, để khi quán đổi giờ mở cửa thì agent không nói giờ cũ mãi.

Đặt trần cho số lượt gọi: bước cuối, và cái bẫy của nó

Cách tiết kiệm cuối cùng thì không liên quan tới giá token. Trong ngày mô phỏng của mình, 4 trong 200 tin làm agent gọi xem_don lặp lại 12 lượt. Với mô hình thật, đó là chuyện có thể xảy ra khi công cụ trả về lỗi mà agent cứ thử lại, và nếu không có trần thì mỗi tin như vậy tốn gấp mười hai lần một tin bình thường.

Cách chặn là đặt số lượt gọi tối đa cho mỗi tin nhắn, mình chọn 4: tra đơn cần 2 lượt, còn dư 2 lượt cho một lần thử lại. Quan trọng hơn con số là việc làm khi chạm trần. Mình không để agent im lặng hay trả câu trả lời cụt, mà chuyển cuộc trò chuyện cho chủ quán, vì một agent đã lặp 4 lần chưa giải quyết được thì khách cần một con người. Dòng cuối của kết quả trên là nó: 295 lượt gọi, 4 tin chuyển cho người, giảm từ 327 lượt và tiền từ 0,2872 xuống 0,2661 đô la.

Con số tiết kiệm này nhỏ nhất trong bốn bước (khoảng 7% của ngày), nhưng giá trị thật của nó nằm ở chỗ khác: nó là giới hạn cho trường hợp xấu nhất. Hai cách trên giúp chi phí bình thường thấp đi, còn trần số lượt đảm bảo một hôm xấu trời không thành hóa đơn gấp mười. Bạn có thể đặt thêm trần cho số token đầu ra (tham số max_tokens trong Messages API) và ngân sách theo ngày cho từng khách, theo cùng tinh thần đó.

Cái bẫy là một trần đặt quá thấp sẽ cắt những tin hợp lệ. Nếu một ngày Mộc thêm công cụ thứ ba (kiểm tra địa chỉ giao), tin về đổi địa chỉ cần ba lượt, và giới hạn 2 sẽ chặn nhầm cả tin đó. Vì vậy mỗi khi đổi trần hoặc đổi công cụ, bạn chạy lại bộ eval ở bài trước và xem có ca nào bắt đầu chuyển cho người một cách vô lý không.

Giữ các con số này bằng test

Mình viết chín test cho demo, vì các con số trong bài chỉ có giá trị khi chúng không âm thầm đổi. Các test kiểm tra cache đọc rẻ hơn giá thường và ghi đắt hơn giá thường, cache hết hạn và được làm mới đúng như tài liệu, tiền tố ngắn hơn mức tối thiểu thì không được cache, đặt giờ ở đầu hướng dẫn làm tiền cao hơn cả khi không dùng cache, từng bước tối ưu không làm tiền tăng, bộ chọn mô hình giữ tin về tiền và đơn ở mô hình lớn, cách nhớ theo nội dung làm lộ đơn còn cách nhớ câu hỏi chung thì không, và trần 4 lượt chuyển đúng 4 tin cho người. Chạy bằng node --test src/chi-phi.test.ts (file test nằm trong repo demo, trong bài này mình không dán nó).

Còn giới hạn của bài. Một, đây là mô phỏng: lưu lượng 200 tin, tỷ lệ các loại tin và tần suất "lặp công cụ" là do mình dựng, và với agent thật bạn phải đo bằng chính số liệu sử dụng mà API trả về. Theo tài liệu của Anthropic, mỗi phản hồi có các trường cache_creation_input_tokens, cache_read_input_tokens và input_tokens, và đó là nơi bạn xem cache có thật sự trúng hay không. Hai, tỷ lệ tiết kiệm phụ thuộc vào tỷ lệ giữa phần cố định và phần đổi: nếu prompt của bạn chỉ có 100 token thì cache chẳng giúp được gì, và nó còn không được bật vì thấp hơn mức tối thiểu. Ba, mình không so chất lượng câu trả lời của mô hình nhỏ và mô hình lớn, vì mô hình ở đây là giả.

Khách vẫn phải chờ, dù hóa đơn đã nhẹ

Đến đây agent của Mộc rẻ hơn khoảng ba phần tư so với lúc đầu, và có trần cho ngày tệ nhất. Nhưng có một thứ tiền không mua được ở bài này: thời gian khách phải đợi. Hãy giả sử mô hình sinh khoảng 40 token mỗi giây (con số giả định của mình, tốc độ thật tùy mô hình và tải). Một câu trả lời 400 token mất khoảng 10 giây, và suốt 10 giây đó khung chat của khách trống trơn rồi bỗng hiện cả đoạn. Cache và mô hình nhỏ đều không thay đổi điều này nhiều. Cách làm cho khách thấy chữ chạy ra ngay khi mô hình vừa nghĩ ra 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ắc lại vì sao prompt dài là tốn tiền, hãy đọc context window là gì. Các câu hỏi về AI agent nằm trong ngân hàng câu hỏi phỏng vấn, và tài liệu đầy đủ về cache nằm ở trang prompt caching của Anthropic.

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.