ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Đánh giá & Quan sát hệ thống AI

AI Builder

Kinh tế token — Chi phí, độ trễ và hiệu quả

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Đơn vị tiền tệ của LLM production là token. Biết cách đo $/task, phân rã latency (TTFT + decode + retrieval + tool), tính break-even với human baseline, và thấy tức thì tác dụng của prompt caching / model cascade / context compression.

lesson120 minĐánh giá & Quan sát hệ thống AIAI Engineer

Dự đoán

CEO hỏi: 'Chatbot hỗ trợ khách hàng tốn bao nhiêu một tháng?' Bạn nên trả lời dựa trên số nào để vừa đúng, vừa an toàn cho quyết định?

Token là đơn vị kỹ thuật, không phải đơn vị business. $/request quá chi tiết, mất hình dung. Hóa đơn tháng trước là lịch sử, không giúp dự báo. Công thức đúng cho dự báo là $/task × volume × buffer — business hiểu ngay, và buffer bảo vệ bạn khỏi spike + prompt length drift.

Khoảnh khắc aha

Token là đơn vị tính tiền kỹ thuật. Nhưng business mới cần biết $/task hoặc $/user. Giữa hai đó có 5 bước chuyển đổi: token → $/call → $/task → $/user-session → $/ngày → $/tháng. Mỗi bước có đòn bẩy tối ưu riêng. Nếu chỉ nhìn "tổng token" bạn sẽ bỏ qua 4 điểm can thiệp có giá trị.

Bốn lưu ý quan trọng

Thử thách 1

Bill LLM của bạn $10k/tháng. Breakdown: 70% input tokens, 30% output. Chiến thuật nào đáng ưu tiên đầu tiên?

Nguyên tắc: tối ưu ở đâu có nhiều tiền nhất. 70% ở input → prompt caching là lever chính xác. Đổi nhà cung cấp có rủi ro quality regression; cắt output chỉ tác động 30% bill; batch API giúp job async chứ không phải real-time.

Thử thách 2

p95 latency = 8s, phân rã 60% decode, 15% TTFT, 15% tool calls, 10% retrieval. Bước đi đúng đầu tiên là gì?

60% nằm ở decode — đòn bẩy đầu tiên phải là cắt output hoặc tăng tokens/s. Cache tác động retrieval (10%) nên không đủ mạnh. Parallelize tool đúng nhưng chỉ đánh 15%. Nguyên tắc: tối ưu theo khối to nhất trong breakdown.

Kinh tế token

Kinh tế token là khung tư duy biến đơn vị kỹ thuật (token) thành đơn vị quyết định (chi phí / tác vụ, độ trễ, break-even so với nhân công). Trong production, bạn cần ba phương trình: công thức chi phí, công thức độ trễ, và công thức chi phí kỳ vọng khi có cascade.

Công thức chi phí cho một task (một lần gọi model):

C=N⋅(tin⋅pin⋅(1−r⋅d)+tout⋅pout)C = N \cdot \left( t_{in} \cdot p_{in} \cdot (1 - r \cdot d) + t_{out} \cdot p_{out} \right)

  • N: số lần gọi model trong một task (1 với chatbot đơn giản, 5-20 với agent).
  • t_in, t_out: input và output tokens trung bình mỗi lần gọi.
  • p_in, p_out: giá USD / token (tính từ bảng giá $/1M ÷ 1,000,000).
  • r: cache hit rate (0..1); d: discount factor cho cached input (thường 0.9 — tức cached tính 10%).

Phân rã latency

Phân rã độ trễ (latency):

L=TTFT+toutRdecode+Lretrieval+LtoolsL = \mathrm{TTFT} + \frac{t_{out}}{R_{decode}} + L_{retrieval} + L_{tools}

TTFT là thời gian từ gửi request đến token đầu tiên — phụ thuộc network, prompt length, và prompt caching. R_decode là tốc độ sinh token (tokens/s) đặc trưng cho từng model. L_retrieval gồm vector search / rerank / reading file. L_tools là tổng thời gian các tool call (tuần tự hoặc song song). Phần nào lớn nhất chính là nơi bạn nên tối ưu trước — xem KV cache và inference optimization để đi sâu.

Model cascade

Với model cascade (cheap-first routing), chi phí kỳ vọng trên toàn phân phối traffic:

E[C]=∑kP(routed to model k)⋅CkE[C] = \sum_{k} P(\text{routed to model } k) \cdot C_k

Thiết kế gate (quyết định có escalate không) quan trọng: gate quá lỏng → nhiều câu khó vẫn dừng ở tier rẻ → quality sụt; gate quá chặt → không ai đi qua tier rẻ → tiết kiệm không có. Calibrate bằng A/B trên một subset thật.

Code đo token

token_budget.py — đo + cảnh báo khi vượt 80%

from dataclasses import dataclass
from typing import Callable

@dataclass
class TokenBudget:
    """Theo dõi token usage theo task. Emit metric + cảnh báo khi vượt 80%."""
    task_id: str
    max_input: int
    max_output: int
    emit_metric: Callable[[str, float, dict], None]

    used_input: int = 0
    used_output: int = 0

    def record(self, in_tok: int, out_tok: int) -> None:
        self.used_input += in_tok
        self.used_output += out_tok
        # Gửi metric realtime — dashboard \$/task dựng trên metric này.
        self.emit_metric(
            "llm.tokens.used",
            in_tok + out_tok,
            {"task": self.task_id, "kind": "total"},
        )
        self._warn_if_over_budget()

    def _warn_if_over_budget(self) -> None:
        in_pct = self.used_input / max(1, self.max_input)
        out_pct = self.used_output / max(1, self.max_output)
        if max(in_pct, out_pct) >= 0.8:
            self.emit_metric(
                "llm.budget.warning",
                max(in_pct, out_pct),
                {"task": self.task_id},
            )

    def cost_usd(self, p_in_per_m: float, p_out_per_m: float,
                 cache_hit: float = 0.0, discount: float = 0.9) -> float:
        eff_in = (p_in_per_m / 1_000_000) * (1 - cache_hit * discount)
        eff_out = p_out_per_m / 1_000_000
        return self.used_input * eff_in + self.used_output * eff_out

token-meter.ts — middleware đo tokens / request

import type { NextRequest, NextResponse } from "next/server";

interface Usage {
  inputTokens: number;
  outputTokens: number;
  cachedInputTokens: number;
  model: string;
  latencyMs: number;
}

// Middleware bọc tầng gọi LLM. Mỗi request emit đúng một record usage.
export async function withTokenMeter<T>(
  req: NextRequest,
  run: () => Promise<{ result: T; usage: Usage }>,
  sink: (u: Usage & { route: string; userId?: string }) => void,
): Promise<T> {
  const started = performance.now();
  const { result, usage } = await run();
  const latencyMs = performance.now() - started;

  // Báo về observability (Datadog, Honeycomb, OTLP...) — một record / request.
  sink({
    ...usage,
    latencyMs,
    route: req.nextUrl.pathname,
    userId: req.headers.get("x-user-id") ?? undefined,
  });

  return result;
}

// Dashboard dùng dữ liệu này để tính $/task realtime:
// SELECT route, SUM(input_tokens * p_in + output_tokens * p_out) / COUNT(DISTINCT task_id)
// FROM llm_usage WHERE ts > now() - interval '1 hour' GROUP BY route;

Prompt caching: cơ chế hash và hit rate

Các nhà cung cấp (Anthropic, OpenAI, Gemini) đều hash prefix của prompt — thường là system prompt + tool schema + tài liệu reference — và cache KV states của prefix đó trong 5-10 phút. Lần request tiếp theo có cùng prefix sẽ trả cached input price (~10% giá chuẩn).

  • Cache bị invalidate khi bạn sửa 1 ký tự ở prefix — kể cả whitespace. Giữ prefix ổn định là quan trọng hơn tối ưu wording.
  • Hit rate trong production steady-state: 80-95% là bình thường nếu traffic liên tục và prefix ổn định. Dưới 50% thường do prefix đổi quá thường (dynamic timestamps, user data chèn vào đầu).
  • Cold start: lần đầu trong 10 phút trả full price. Chi phí build cache = 1.25× giá gốc (có nơi tính break-even sau 2 hit). Do đó cache chỉ hiệu quả khi có traffic đều.
  • Kỹ thuật thiết kế: đẩy mọi phần dynamic xuống cuối prompt; phần ổn định (system, tool schema, sample data) lên đầu. Mỗi 1k token prefix ổn định thêm vào có thể giúp hit rate tăng ~5% nhờ tăng lợi ích việc cache.

Ba con đường giảm cost

Ba hướng cùng mục tiêu "giảm cost", nhưng đánh đổi khác nhau:

  • Distillation: train model nhỏ bắt chước model lớn trên task cụ thể. Đầu tư lớn (data + training), nhưng một khi có rồi thì giá inference rất thấp và ổn định. Phù hợp workload cố định, lặp nhiều (extract entity, classify).
  • Context compression: tóm tắt history sau N turn, giữ lại chỉ phần quan trọng. Giảm input tokens ngay lập tức (20-40%), không cần training. Rủi ro: mất thông tin → quality sụt. Best practice: tóm tắt bằng LLM khác, lưu thread history đầy đủ song song phòng cần roll-back.
  • Cascade: không đổi model, chỉ thêm lớp routing. Dễ triển khai, dễ rollback. Rủi ro lớn nhất là gate calibration — gate sai khiến phần lớn traffic vẫn lên tier đắt, hoặc tệ hơn, quality degradation vì dừng quá sớm ở tier rẻ.

Quy trình thực tế: caching trước (zero trade-off, chỉ cần kỹ thuật), cascade tiếp (đánh đổi phức tạp routing), compression song song, và chỉ cân nhắc distillation khi volume đủ lớn (thường > 100M token/tháng cùng task).

Case study minh hoạ: chatbot CSKH

Case study minh hoạ: các số liệu và sự kiện dưới đây không phải dữ liệu công khai của MoMo.

Bối cảnh. Một đội ở MoMo triển khai chatbot hỗ trợ CSKH: tra đơn, hủy giao dịch, hướng dẫn liên kết thẻ. Volume: ~180k conversation/ngày, mỗi conversation trung bình 4 turn, dùng gpt-4o-full cho toàn bộ.

Trước khi đo. Team nghĩ tốn "khoảng vài nghìn đô". Không có dashboard $/task, không có alert khi spike. Cuối tháng hóa đơn về: $18.000 — gần bằng 30 nhân viên CSKH. Sếp hỏi tại sao, không ai trả lời chắc.

Đo trước, tối ưu sau. Tuần 1-2: chỉ thêm observability. Kết quả phân rã:

  • 72% cost ở input tokens (system prompt 3.2k + FAQ 4k + lịch sử hội thoại).
  • 28% ở output. Trong output, 30% là câu trả lời đơn giản (yes/no/status).
  • p95 latency 6.4s — decode 55%, TTFT 20%, tool 15%, retrieval 10%.

Ba can thiệp.

  1. Prompt caching cho system prompt + FAQ: hit rate steady-state đạt 88% → input cost giảm ~79%.
  2. Cascade gpt-4o-mini → gpt-4o-full: gate là một classifier nhỏ kiểm intent. 73% traffic (status, FAQ đơn giản) dừng ở mini; 27% khó (policy edge, refund) lên full. $/req giảm thêm ~45%.
  3. Tóm tắt context > 5 turn: history dài tóm thành 300 token thay vì gửi full 2-3k token. Input tiếp tục giảm 15% ở phần variable.

Kết quả sau 4 tuần. Hóa đơn: $4.200/tháng (giảm 77%). CSAT không đổi (lấy từ 2k rating sampling mỗi tuần). p95 latency: 3.8s (nhờ mini nhanh hơn cho 73% traffic). Dashboard $/task realtime thay cho "đoán cuối tháng"; alert khi spike > 20% so với baseline 7 ngày.

Bài học. Thứ tự đúng: đo → tìm Pareto → tối ưu đúng chỗ → theo dõi CSAT. Nếu team đi thẳng vào "đổi model rẻ hơn" từ đầu, khả năng cao CSAT tụt rồi phải rollback — mất cả tiền và niềm tin của sếp vào AI team.

Tóm tắt

  • Đơn vị tính tiền là token, nhưng đơn vị quyết định phải là $/task hoặc $/user — có 5 bước chuyển đổi giữa hai đó.
  • Luôn đo trước khi tối ưu: observability tokens/request + dashboard $/task realtime là tiền đề, không phải bonus.
  • Latency có 4 thành phần (TTFT + decode + retrieval + tool) — tối ưu theo khối to nhất, không theo khối dễ nhất.
  • Prompt caching là đòn bẩy lớn nhất, rủi ro thấp nhất — tiết kiệm 70-90% chi phí input cho system prompt dài.
  • Model cascade (Haiku → Sonnet → Opus) tính chi phí kỳ vọng, không chi phí tối đa — gate calibration là phần khó nhất.
  • Break-even với human baseline (15tr VND/tháng ≈ $600) là cách nhanh nhất giúp sếp hiểu giá trị đầu tư — đừng chỉ đưa con số USD trần trụi.

Continue the module

Lesson 5 of 7