Tối ưu chi phí: Prompt caching, model selection, rate limits — Chạy agent không lo 'hóa đơn shock'

Agent chạy tự động 24/7 nghe có vẻ tuyệt, cho đến khi bạn nhận hóa đơn 5 triệu đồng chỉ sau một đêm vì agent "quên" mình đã hỏi câu đó 1000 lần. Đây là lý do tại sao ngay từ bước thiết lập đầu tiên, bạn cần dạy agent cách "tiêu tiền khôn ngoan" — qua ba công cụ đơn giản: cache lặp lại, chọn model đúng cỡ, và giới hạn tốc độ gọi API.

Vấn đề

Khi mới bắt đầu, developer thường mắc ba lỗi tốn kém kinh điển:

Lặp lại vô thức: Agent gửi lại toàn bộ lịch sử chat 4000 tokens chỉ để hỏi thêm một câu ngắn. Nhà cung cấp LLM tính tiền theo token, nên mỗi turn bạn trả tiền cho cả đoạn dài đã gửi trước đó.

Dùng "súng thần công" bắn ruồi: Gọi GPT-4o cho task đơn giản như rút gọn URL hay định dạng JSON, trong khi GPT-4o-mini làm được với giá bằng 1/30.

Tsunami requests: Cron job cấu hình sai khiến agent gửi 1000 request/phút khi gặp lỗi logic vòng lặp. Kết quả: vừa bị nhà cung cấp khóa API (rate limit exceeded), vừa mất tiền oan cho request bị từ chối.

Ví dụ thực tế: Một Telegram bot FAQ đơn giản, nếu không caching, mỗi câu trả lời tốn khoảng 0.008$(input 3k tokens × 0.002$/1k). Với 1000 user tương tác mỗi ngày, tháng đầu tiên bạn nhận hóa đơn ~240$(khoảng 6 triệu VNĐ) — trong khi có thể giảm xuống dưới 40$ nếu tối ưu đúng cách.

Ý tưởng cốt lõi

Bản chất của việc tối ưu chi phí agent là phân tầng thông minh: đừng xử lý mọi thứ như nhau, đừng trả tiền cho sự lặp lại, và đừng để hệ thống "chạy tự do" không có rào chắn.

Prompt Caching: Trả tiền một lần, dùng cả tháng

Khi bạn chat với AI qua API, mỗi tin nhắn mới phải kèm toàn bộ lịch sử cũ để AI nhớ ngữ cảnh. Nếu bạn đã gửi 10 trang tài liệu (10k tokens) làm context, rồi hỏi 10 câu ngắn, bạn trả tiền cho 100k tokens (10k × 10 lần) — dù phần tài liệu không đổi.

Prompt caching (Anthropic gọi là Prompt Caching, OpenAI gọi là Context Caching) cho phép bạn "đánh dấu" phần context cố định (system prompt, SOUL.md, tài liệu RAG) để nhà cung cấp lưu trữ sẵn trên server. Lần sau, bạn chỉ trả tiền cho phần tin nhắn mới thêm vào, còn phần cũ giảm giá 90%.

Cách khai báo trong code Anthropic API:

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "[Đặt toàn bộ SOUL.md và tài liệu dài ở đây]",
                    "cache_control": {"type": "ephemeral"}  # Đánh dấu cache
                },
                {
                    "type": "text",
                    "text": "Câu hỏi ngắn của user"  # Không cache
                }
            ]
        }
    ]
)

Model Selection: Đúng việc, đúng giá

Thay vì dùng một model cho mọi việc, bạn triển khai router để chọn "công nhân" phù hợp:

Tier 1 (Giá rẻ, tốc độ cao): GPT-4o-mini, Claude 3 Haiku, hoặc Ollama local — cho tasks đơn giản: format JSON, phân loại intent, kiểm tra cú pháp, trích xuất entity.

Tier 2 (Suy luận phức tạp): GPT-4o, Claude 3.5 Sonnet — chỉ khi cần viết code, phân tích tài liệu pháp lý dài, hoặc ra quyết định business logic đa bước.

Pattern "Cascade" phổ biến: Dùng model rẻ thử trước. Nếu confidence thấp (<0.7) hoặc output chứa từ khóa "tôi không chắc", escalate lên model đắt.

def route_query(user_message: str) -> str:
    # Dùng model rẻ phân loại độ phức tạp
    complexity = cheap_llm.classify(user_message)
    
    if complexity == "simple" or len(user_message) < 50:
        return "gpt-4o-mini"      # ~0.00015$/1K tokens
    else:
        return "claude-3-5-sonnet" # ~0.003$/1K tokens, đắt gấp 20 lần

Rate Limiting: Thắng dây an toàn

API của OpenAI/Anthropic có giới hạn TPM (Tokens Per Minute) và RPM (Requests Per Minute). Vượt quá sẽ nhận lỗi 429 Too Many Requests, và request đó vẫn có thể bị tính tiền nếu đã xử lý một phần.

Giải pháp là implement Token Bucket — một hàng đợi có "nguồn nước" chảy chậm:

import time
from threading import Lock

class RateLimiter:
    def __init__(self, max_rpm: int):
        self.tokens = max_rpm
        self.rate = max_rpm / 60.0  # tokens per second
        self.last_update = time.time()
        self.lock = Lock()
    
    def acquire(self, tokens: int = 1) -> bool:
        with self.lock:
            now = time.time()
            elapsed = now - self.last_update
            self.tokens += elapsed * self.rate
            if self.tokens > self.rate * 60:
                self.tokens = self.rate * 60
            
            if self.tokens >= tokens:
                self.tokens -= tokens
                return True
            return False

# Sử dụng: chỉ gọi API khi acquire() trả về True
if limiter.acquire():
    response = call_llm_api()
else:
    queue_for_later()  # Hoặc trả lời "Hệ thống bận, thử lại sau"

Khoảnh khắc "à ra vậy": Chi phí agent không phải là giá model cố định, mà là tích lũy của sự lãng phí. Cache giúp bạn không trả tiền cho sự lặp lại. Model selection giúp bạn không trả tiền cho sự "dư thừa". Rate limit giúp bạn không trả tiền cho sự "mất kiểm soát".

Tại sao nó hoạt động

Logic caching: LLM là stateless theo thiết kế — mỗi request độc lập. Nhưng nhà cung cấp có thể lưu KV-cache (Key-Value cache) của attention mechanism trên GPU, tránh tính toán lại cho cùng một prefix prompt. Điều này giảm tải tính toán cho họ nên họ sẵn sàng giảm giá 90% cho bạn.

Logic model selection: Không phải task nào cũng cần 175 tỷ tham số để nhận diện "đây là câu hỏi về giờ mở cửa". Nhưng trade-off là model rẻ có thể "ảo tưởng" (hallucinate) nhiều hơn. Chiến lược cascade là cách tối ưu kỳ vọng: chi phí trung bình = (xác suất đúng × giá rẻ) + (xác suất sai × (giá rẻ + giá đắt)). Nếu model rẻ đúng 90% thời gian, bạn tiết kiệm 88% chi phí so với dùng model đắt 100%.

Logic rate limiting: API provider bán capacity theo "đường ống". Nếu bạn đổ nước quá nhanh, ống vỡ (server crash). Rate limit là bảo hiểm hai chiều: tránh bạn tốn tiền vô ý (ví dụ: bug vòng lặp vô hạn gọi API) và bảo vệ hệ thống chung.

Trade-off cần nhớ: Caching tăng latency nhẹ lần đầu (phải hash và lưu), nhưng giảm latency turn sau (server không cần parse lại). Model rẻ thường nhanh hơn (tham số ít, suy luận nhanh). Rate limiting làm chậm agent nhưng cứu ví tiền và tránh bị ban IP.

Ý nghĩa thực tế

So sánh chi phí cho 1 triệu tokens input (số liệu tham khảo tháng 6/2025):

Case study thực tế: Một shop thời trang Việt Nam chạy agent support khách hàng trên Zalo OA.

• Trước: Dùng GPT-4o cho mọi câu hỏi (cả "còn size S không" lẫn "so sánh chất liệu"). Chi phí: ~800$/tháng.
• Sau: Dùng Claude 3 Haiku cho 90% FAQ đơn giản, chỉ escalate lên GPT-4o cho câu hỏi phức tạp về chính sách đổi trả. Kết hợp prompt caching cho phần chính sách cố định. Chi phí: ~90$/tháng. Tiết kiệm 88%.

Hạn chế cần biết:

• Prompt caching chỉ hiệu quả nếu có nhiều turn trong cùng session. Nếu agent của bạn là "one-shot" (hỏi một câu, trả lời xong, disconnect), caching không giúp được.
• Model selection cần heuristic tốt — nếu phân loại sai, bạn tốn tiền gọi cả model rẻ lẫn model đắt (cascade cost).
• Rate limit có thể làm agent "đói" khi traffic thực sự tăng đột biến — cần strategy queue hoặc scale horizontally nhiều API key.

Đào sâu hơn

Tài liệu chính thức:

• Anthropic Prompt Caching — Hướng dẫn đánh dấu cache_control và giới hạn 5 phút TTL
• OpenAI Rate Limits — Tier system và best practices xử lý 429 errors
• Ollama Documentation — Chạy local models miễn phí, trade-off là hardware cost

Bài liên quan TroiSinh:

Cùng cụm (getting-started):

Đọc tiếp (level-1 — nâng cao):

Mở rộng:

• GitHub: openai-cookbook — Examples về model selection routing và caching patterns
• Blog: "The True Cost of AI Agents" — Phân tích chi phí ẩn (token wasted, retries, error cascades) mà nhiều người bỏ qua khi tính toán budget