Mở đầu: Câu chuyện thực tế từ một startup AI tại Hà Nội

Tôi vẫn nhớ rõ buổi sáng tháng 3/2026, khi đội ngũ kỹ thuật của một startup AI tại Hà Nội gọi điện cho tôi trong tình trạng hoảng loạn. Hệ thống chatbot chăm sóc khách hàng của họ vừa bị khách hàng phản ánh tràn lan: "Trả lời quá dài, đọc không hết", "Token billing cao gấp 3 lần dự kiến", và "Server trả về đôi khi cắt ngang giữa chừng".

Bối cảnh lúc đó: startup này đang phục vụ 50,000 người dùng với 200,000 requests mỗi ngày trên nền tảng thương mại điện tử. Họ đã đầu tư kiến trúc microservices, nhưng vấn đề nằm ở cách họ kiểm soát output của LLM — một vấn đề tưởng nhỏ nhưng gây thiệt hại lớn.

Bài toán: Tại sao output length control quan trọng?

Khi làm việc với LLM, có ba vấn đề chính liên quan đến độ dài output:

Với mức giá thị trường thông thường (GPT-4.1 input $8/MTok, output $24/MTok), việc để model sinh ra 500 token thay vì 150 token có thể tăng chi phí gấp 3 lần cho mỗi request.

Chiến lược 1: max_tokens — Giới hạn cứng

Tham số max_tokens là cách đơn giản nhất để giới hạn độ dài output. Khi model đạt đến giới hạn này, response sẽ bị cắt ngang ngay lập tức.

import requests

def call_llm_with_max_tokens(prompt: str, max_tokens: int = 150):
    """
    Ví dụ: Giới hạn output 150 tokens để kiểm soát chi phí
    - Chatbot trả lời ngắn gọn
    - Tổng đài tự động
    - Summary generation
    """
    url = "https://api.holysheep.ai/v1/chat/completions"
    
    headers = {
        "Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-4.1",
        "messages": [
            {"role": "user", "content": prompt}
        ],
        "max_tokens": max_tokens,  # Giới hạn cứng
        "temperature": 0.7
    }
    
    response = requests.post(url, headers=headers, json=payload)
    return response.json()


Use case cụ thể: Chatbot trả lời khách hàng

result = call_llm_with_max_tokens(
    prompt="Tóm tắt đơn hàng #12345 trong 2-3 câu",
    max_tokens=80  # Đủ ngắn cho SMS/Notification
)

print(result['choices'][0]['message']['content'])

Output: "Đơn #12345 đang vận chuyển, dự kiến giao 25/01. Mã vận đơn: VN123456"

Chiến lược 2: stop sequence — Giới hạn thông minh

Stop sequence cho phép bạn định nghĩa một hoặc nhiều chuỗi ký tự. Khi model gặp chuỗi này, nó sẽ dừng ngay lập tức và trả về mọi thứ TRƯỚC chuỗi đó. Điểm mạnh: output luôn kết thúc đúng format, không bị cắt ngang.

import requests

def generate_structured_response(prompt: str, format_schema: str):
    """
    Ví dụ: Yêu cầu model trả về JSON với stop sequence để đảm bảo format
    - Luôn kết thúc bằng 
    - Không bao giờ bị cắt giữa JSON
    - Parse an toàn 100%
    """
    url = "https://api.holysheep.ai/v1/chat/completions"
    
    headers = {
        "Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-4.1",
        "messages": [
            {
                "role": "system", 
                "content": f"Trả lời JSON với schema: {format_schema}. Kết thúc bằng "
            },
            {"role": "user", "content": prompt}
        ],
        "max_tokens": 500,
        "stop": ["", "\n\n---", "ERROR:"],  # Multiple stop sequences
        "temperature": 0.3  # Giảm randomness cho structured output
    }
    
    response = requests.post(url, headers=headers, json=payload)
    raw_content = response.json()['choices'][0]['message']['content']
    
    # Parse JSON an toàn vì chúng ta biết chắc format
    if "" in raw_content:
        json_str = raw_content.split("")[0].replace("```json", "").strip()
        return json_str
    
    return raw_content


Use case: API trả về danh sách sản phẩm

result = generate_structured_response(
    prompt="Liệt kê 5 sản phẩm bán chạy nhất tháng này",
    format_schema='{"products": [{"id": int, "name": string, "price": float}]}'
)

print(result)

Output: Luôn valid JSON, không bao giờ bị cắt giữa chừng

Chiến lược 3: Kết hợp max_tokens + stop sequence tối ưu

Đây là chiến lược tôi khuyên dùng cho production — kết hợp cả hai để có cả safety net và format guarantee.

import requests
import time

class LLMOutputController:
    """
    Production-ready controller cho kiểm soát output LLM
    - max_tokens: Giới hạn cứng phòng trường hợp stop sequence không trigger
    - stop: Đảm bảo format đúng
    - Streaming: Giảm perceived latency
    """
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })
    
    def chat(self, prompt: str, max_tokens: int = 200, 
             stop_sequences: list = None, temperature: float = 0.7) -> dict:
        """
        Chat với output control tối ưu
        """
        payload = {
            "model": "gpt-4.1",
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": max_tokens,
            "temperature": temperature,
            "stream": False
        }
        
        if stop_sequences:
            payload["stop"] = stop_sequences
        
        start_time = time.time()
        response = self.session.post(
            f"{self.base_url}/chat/completions", 
            json=payload
        )
        latency_ms = (time.time() - start_time) * 1000
        
        result = response.json()
        result['_meta'] = {
            'latency_ms': round(latency_ms, 2),
            'model': 'gpt-4.1',
            'provider': 'HolySheep AI'
        }
        
        return result
    
    def batch_summarize(self, texts: list, max_tokens: int = 50) -> list:
        """
        Batch processing với token budget chặt chẽ
        """
        results = []
        for text in texts:
            prompt = f"Tóm tắt trong 1 câu: {text[:500]}"  # Giới hạn input
            result = self.chat(prompt, max_tokens=max_tokens)
            results.append(result['choices'][0]['message']['content'])
        
        return results


Khởi tạo controller

controller = LLMOutputController(api_key="YOUR_HOLYSHEEP_API_KEY")


Ví dụ 1: Chatbot ngắn gọn

chat_result = controller.chat(
    prompt="Giải thích JSON trong 1 câu",
    max_tokens=30,
    stop_sequences=["."]
)
print(f"Latency: {chat_result['_meta']['latency_ms']}ms")
print(f"Output: {chat_result['choices'][0]['message']['content']}")


Ví dụ 2: Batch summary cho dashboard

summaries = controller.batch_summarize([
    "Bài viết về AI...",
    "Review sản phẩm...",
    "Tin tức công nghệ..."
], max_tokens=40)

for i, summary in enumerate(summaries):
    print(f"{i+1}. {summary}")

Bảng so sánh: max_tokens vs stop sequence

Tiêu chí max_tokens stop_sequence
Mục đích chính Giới hạn số token tối đa Dừng tại điểm format chuẩn
Khi nào dừng Đạt số token giới hạn Gặp chuỗi định nghĩa trước
Rủi ro Có thể cắt giữa câu/format Model có thể không gặp stop sequence
Use case tốt nhất Cost-critical, latency-sensitive Structured output, code generation
Tính deterministic Luôn dừng tại token N Phụ thuộc nội dung model sinh

Case study: Startup tại Hà Nội giảm 83% chi phí LLM

Quay lại câu chuyện ở đầu bài. Sau khi tôi hỗ trợ đội ngũ startup này triển khai chiến lược output control, kết quả sau 30 ngày thực sự ấn tượng:

Chi tiết triển khai trên HolySheep AI

Điều đặc biệt là startup này đã chuyển từ nhà cung cấp cũ sang HolySheep AI với nhiều lợi ích vượt trội:

So sánh chi phí: HolySheep vs nhà cung cấp cũ

Với volume 200,000 requests/ngày và trung bình 85 tokens/output:

Bảng giá tham khảo HolySheep AI 2026

Model Input ($/MTok) Output ($/MTok) Use case tối ưu
GPT-4.1 $8.00 $24.00 Complex reasoning, code generation
Claude Sonnet 4.5 $15.00 $75.00 Long-form writing, analysis
Gemini 2.5 Flash $2.50 $10.00 High-volume, low-latency
DeepSeek V3.2 $0.42 $1.68 Cost-sensitive, bulk processing

Lỗi thường gặp và cách khắc phục

Lỗi 1: Output bị cắt giữa JSON khi dùng max_tokens quá nhỏ

# ❌ SAI: max_tokens quá nhỏ, JSON bị cắt
payload = {
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": "Trả về JSON 10 sản phẩm"}],
    "max_tokens": 100  # Quá nhỏ cho 10 sản phẩm
}

Kết quả: {"products": [{"id": 1, "name": "SP1"}, {"id": 2...



✅ ĐÚNG: Tính toán token hợp lý


10 sản phẩm × ~50 tokens/sản phẩm = 500 tokens minimum

payload = {
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": "Trả về JSON 10 sản phẩm"}],
    "max_tokens": 800,  # Buffer 60% cho safety
    "stop": [""]  # Stop sequence như backup
}

Lỗi 2: Stop sequence không bao giờ trigger → infinite loop

# ❌ SAI: Stop sequence không khớp với output thực tế
payload = {
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": "Liệt kê màu sắc"}],
    "stop": [""],  # Model không bao giờ output 
    "max_tokens": 10  # Có thể không đủ
}

Rủi ro: Model không dừng đúng chỗ



✅ ĐÚNG: Kết hợp max_tokens làm fallback

payload = {
    "model": "gpt-4.1",
    "messages": [
        {"role": "system", "content": "Trả lời theo format: ITEM1, ITEM2, ITEM3. Kết thúc bằng END"},
        {"role": "user", "content": "Liệt kê 5 màu sắc"}
    ],
    "stop": ["END", ".\n"],  # Multiple stop sequences
    "max_tokens": 50,  # Đủ cho 5 items + buffer
    "temperature": 0.2  # Giảm randomness
}

Kết quả: "Đỏ, Xanh, Vàng, Trắng, Đen. END"

Lỗi 3: Không xử lý streaming khi dùng stop sequence

# ❌ SAI: Streaming nhưng không kiểm tra stop trong stream
def stream_without_stop_check():
    payload = {
        "model": "gpt-4.1",
        "messages": [{"role": "user", "content": "Code Python 100 dòng"}],
        "max_tokens": 500,
        "stream": True
    }
    # Vấn đề: Không detect stop sequence trong stream
    # Có thể nhận partial output bị cắt
    

✅ ĐÚNG: Buffer và kiểm tra stop trong stream

def stream_with_stop_check(stop_sequences: list):
    payload = {
        "model": "gpt-4.1",
        "messages": [{"role": "user", "content": "Code Python ngắn"}],
        "max_tokens": 300,
        "stream": True
    }
    
    response = requests.post(
        "https://api.holysheep.ai/v1/chat/completions",
        headers={"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"},
        json=payload,
        stream=True
    )
    
    buffer = ""
    for line in response.iter_lines():
        if line:
            data = json.loads(line.decode('utf-8').replace('data: ', ''))
            if 'choices' in data:
                content = data['choices'][0].get('delta', {}).get('content', '')
                buffer += content
                
                # Kiểm tra stop sequence
                for stop_seq in stop_sequences:
                    if stop_seq in buffer:

Tài nguyên liên quan
Bài viết liên quan