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

Evaluating routing across providers.

Start learning
← Xu hướng mới

AI Researcher

Ngữ cảnh dài — AI đọc cả cuốn sách

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

Khả năng mô hình xử lý hàng trăm nghìn đến hàng triệu token trong một lần, cho phép phân tích tài liệu dài.

lesson120 minXu hướng mớiAI Researcher

Dự đoán

Bạn cần AI phân tích hợp đồng 500 trang (250K tokens) để tìm điều khoản bất lợi. Cách nào hiệu quả nhất?

Long context models (Claude, Gemini) đọc cả 500 trang trong 1 lần — hiểu toàn cảnh, không bị mất context giữa các phần. Giống đọc nguyên cuốn sách thay vì đọc từng trang rời. Điều khoản ở trang 3 liên quan đến trang 487? Long context bắt được!

Long-context model hoạt động thế nào

Training data dài + positional tricks (RoPE scaling, YaRN) + continued pretraining giúp attention phân bố đều hơn — chunk ở cuối tài liệu vẫn được nhìn thấy bởi query ở đầu.

Khoảnh khắc A-ha

Từ 4K tokens (5 trang) đến 1M tokens (1250 trang) chỉ trong 2 năm! Như từ đọc 1 bài báo sang đọc cả cuốn tiểu thuyết trong 1 lần. Long context không chỉ là 'nhiều hơn' — nó cho phép hiểu toàn cảnh thay vì ghép nhiều mảnh nhỏ.

Điểm tinh tế: context dài không đồng nghĩa với nhớ đều. Model có window 1M nhưng attention vẫn có thể "lười" ở giữa. Đo bằng benchmark RULER/LongBench quan trọng hơn con số "supports 1M tokens" trên marketing page.

Thử thách

Llama 70B với context 1M tokens: weights FP16 khoảng 140GB, KV cache theo công thức ở mục Lý thuyết. Cần bao nhiêu GPU A100 80GB?

Đính chính: nguồn ban đầu ghi KV cache khoảng 80GB ở 1M tokens, không khớp với công thức của chính bài (≈320GB). Đáp án đã được sửa theo công thức.

Bạn có tài liệu 600K tokens và cần hỏi 50 câu hỏi khác nhau về nó. Cách nào rẻ nhất trên Claude?

Anthropic prompt caching: khi prefix (document) lặp lại, phần cached tính giá 10% input tokens (read) hoặc 125% (write lần đầu). 50 queries trên 600K tokens: không cache = 30M tokens. Có cache: 600K write + 49 x 600K x 0.1 = ~3.5M — tiết kiệm ~88%.

Lý thuyết

Long Context là khả năng model xử lý hàng trăm nghìn đến hàng triệu tokens trong 1 lần — cho phép phân tích tài liệu dài, codebase, video. Khái niệm mở rộng của context window truyền thống, thường đi kèm kiến trúc thay thế như state-space models và tối ưu KV cache để kiểm soát chi phí bộ nhớ.

Attention complexity:

Attention FLOPs=O(N2⋅d)KV Cache=O(N⋅d⋅L)\text{Attention FLOPs} = O(N^2 \cdot d) \quad \text{KV Cache} = O(N \cdot d \cdot L)

Kỹ thuật mở rộng context:

  • RoPE scaling: Nội suy vị trí tương đối, mở rộng từ 4K → 128K+ không cần retrain
  • Flash Attention: Giảm memory từ O(N²) xuống O(N) bằng tiling
  • GQA (Grouped Query Attention): Giảm KV heads 4-8x, giảm KV cache tương ứng
  • Ring Attention: Phân phối sequence qua nhiều GPU, overlap compute và communication
  • Prompt / context caching: Cache KV của prefix không đổi, giảm chi phí re-query 5-10x

Công thức KV cache

Công thức tổng quát:

KV Cache=2×nlayers×nkv heads×dhead×N×bytes\text{KV Cache} = 2 \times n_{\text{layers}} \times n_{\text{kv heads}} \times d_{\text{head}} \times N \times \text{bytes}

Với Llama 3 70B (80 layers, 8 KV heads sau GQA, d_head=128), FP16 (2 bytes):

  • Per token: 2 × 80 × 8 × 128 × 2 = 327 KB/token
  • 100K tokens: ~32 GB
  • 1M tokens: ~320 GB (không còn fit 1 GPU)

Đây là lý do sản xuất: quantize KV xuống INT8 (giảm 2x) hoặc INT4 (giảm 4x) với ít tổn thất chất lượng. Hoặc dùng MLA như DeepSeek-V2 để giảm tiếp 5-10x (theo nguồn bài, chưa kiểm chứng).

Chọn chiến lược: long context, RAG hay hybrid

Rule of thumb theo kích thước corpus:

  • < 200K tokens, 1 tài liệu: long context thuần. Đơn giản, accuracy cao.
  • 200K-2M tokens, nhiều query lặp: long context + prompt caching. Rẻ hơn 5-10x.
  • 2M-100M tokens: RAG (retrieve top-K) → long context xử lý K chunks được chọn.
  • > 100M tokens, freshness cao: RAG thuần. Long context không khả thi cost-wise.

Hybrid thường thắng: retrieval gọi nhanh (50ms), trả về 50-100 chunks liên quan nhất, đưa vào long context (200K) để model reason toàn cảnh. Cân bằng giữa scale và chất lượng.

Code mẫu

Claude API context window — Python

import anthropic

client = anthropic.Anthropic()

# Đọc toàn bộ tài liệu 500 trang
with open("contract_500_pages.txt") as f:
    full_document = f.read()  # ~250K tokens

# Use prompt caching so re-asking is cheap
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=4096,
    system=[
        {
            "type": "text",
            "text": (
                "Bạn là trợ lý pháp lý. Phân tích hợp đồng được cung cấp "
                "và trả lời chính xác, ngắn gọn, trích dẫn điều khoản."
            ),
            "cache_control": {"type": "ephemeral"},
        },
        {
            "type": "text",
            "text": full_document,
            "cache_control": {"type": "ephemeral"},
        },
    ],
    messages=[{
        "role": "user",
        "content": (
            "Liệt kê các điều khoản phạt có thể gây bất lợi cho Bên A, "
            "kèm số chương và trích dẫn."
        ),
    }],
)

# Lần đầu: 'cache_creation_input_tokens' = ~250K (125% giá input)
# Lần thứ 2+: 'cache_read_input_tokens' = ~250K (10% giá input)
# → giảm chi phí tới 90% cho các câu hỏi follow-up
for block in response.content:
    if block.type == "text":
        print(block.text)

print("\nUsage:", response.usage)

Đo tokens và chia nhỏ khi vượt context

import anthropic
from dataclasses import dataclass

client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-5"

# ----------------------------------------------------------------------------
# Count helpers — dùng API count_tokens để ước lượng chính xác theo tokenizer
# của Claude (khác tokenizer OpenAI, nên không dùng tiktoken).
# ----------------------------------------------------------------------------

def count_tokens(text: str, model: str = MODEL) -> int:
    resp = client.messages.count_tokens(
        model=model,
        messages=[{"role": "user", "content": text}],
    )
    return resp.input_tokens

def fits_in_context(text: str, budget: int = 180_000) -> bool:
    """Reserve ~20K tokens cho system prompt + response."""
    return count_tokens(text) <= budget

# ----------------------------------------------------------------------------
# Chunking fallback — khi document > context window
# Chia theo đoạn văn, tôn trọng biên đoạn để giữ semantic coherence.
# ----------------------------------------------------------------------------

@dataclass
class Chunk:
    text: str
    tokens: int
    index: int

def chunk_for_rag(text: str, chunk_tokens: int = 2000) -> list[Chunk]:
    """Split khi document > 1M tokens hoặc cần RAG index."""
    paragraphs = text.split("\n\n")
    chunks: list[Chunk] = []
    current: list[str] = []
    current_toks = 0
    for p in paragraphs:
        toks = count_tokens(p)
        if current_toks + toks > chunk_tokens and current:
            chunks.append(
                Chunk(
                    text="\n\n".join(current),
                    tokens=current_toks,
                    index=len(chunks),
                )
            )
            current = [p]
            current_toks = toks
        else:
            current.append(p)
            current_toks += toks
    if current:
        chunks.append(
            Chunk(
                text="\n\n".join(current),
                tokens=current_toks,
                index=len(chunks),
            )
        )
    return chunks

# ----------------------------------------------------------------------------
# Strategy selector — chọn long context / hybrid / RAG theo kích thước
# ----------------------------------------------------------------------------

def choose_strategy(doc_path: str) -> str:
    with open(doc_path) as f:
        text = f.read()
    tokens = count_tokens(text)

    if tokens < 180_000:
        return "long-context-single-call"
    if tokens < 900_000:
        return "long-context-with-caching"
    if tokens < 10_000_000:
        return "hybrid-retrieval-plus-long-context"
    return "pure-rag"

# ----------------------------------------------------------------------------
# Example run — áp dụng chiến lược đã chọn
# ----------------------------------------------------------------------------

def analyze(doc_path: str, question: str) -> str:
    strategy = choose_strategy(doc_path)
    text = open(doc_path).read()

    if strategy == "long-context-single-call":
        resp = client.messages.create(
            model=MODEL,
            max_tokens=2048,
            messages=[{
                "role": "user",
                "content": f"Tài liệu:\n{text}\n\nCâu hỏi: {question}",
            }],
        )
        return resp.content[0].text

    if strategy == "long-context-with-caching":
        resp = client.messages.create(
            model=MODEL,
            max_tokens=2048,
            system=[
                {"type": "text", "text": "Bạn là trợ lý phân tích tài liệu."},
                {
                    "type": "text",
                    "text": text,
                    "cache_control": {"type": "ephemeral"},
                },
            ],
            messages=[{"role": "user", "content": question}],
        )
        return resp.content[0].text

    # hybrid or pure RAG: embed + top-K retrieval, omitted for brevity
    raise NotImplementedError(strategy)

print(analyze("huge_doc.txt", "Điều khoản phạt tối đa là bao nhiêu?"))

Đo 'lost in the middle' bằng needle-in-a-haystack tự chế

"""
Đơn giản hoá: nhét 1 "needle" (câu có thể truy vấn) vào vị trí d (0..1)
trong haystack dài N tokens, sau đó hỏi model nội dung needle.
So sánh accuracy theo vị trí → tái hiện 'lost in the middle'.
"""

import anthropic
import random
import string

client = anthropic.Anthropic()

NEEDLE = (
    "Mật khẩu truy cập khẩn cấp của Bên A là 'LOVELACE-1815'. "
    "Chỉ dùng trong tình huống khẩn cấp, không chia sẻ với bên thứ ba."
)

def make_haystack(n_tokens: int) -> str:
    """Sinh filler bằng văn bản luật giả lập."""
    paragraph = (
        "Điều khoản tiếp theo quy định các trách nhiệm bên liên quan "
        "trong quá trình thực hiện công việc theo hợp đồng. "
    )
    return (paragraph * (n_tokens // 20))[: n_tokens * 4]

def inject_needle(haystack: str, depth: float) -> str:
    pos = int(len(haystack) * depth)
    return haystack[:pos] + "\n\n" + NEEDLE + "\n\n" + haystack[pos:]

def ask(text: str) -> str:
    resp = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=256,
        messages=[{
            "role": "user",
            "content": (
                "Dựa vào tài liệu bên dưới, trích xuất 'mật khẩu khẩn cấp' "
                "nếu có. Trả lời 'NOT FOUND' nếu không có.\n\n"
                f"{text}\n\nTrả lời:"
            ),
        }],
    )
    return resp.content[0].text.strip()

def evaluate(n_tokens: int, depths: list[float]) -> dict[float, bool]:
    haystack = make_haystack(n_tokens)
    results: dict[float, bool] = {}
    for d in depths:
        doc = inject_needle(haystack, d)
        answer = ask(doc)
        results[d] = "LOVELACE-1815" in answer
    return results

# Example run
if __name__ == "__main__":
    depths = [0.0, 0.1, 0.25, 0.5, 0.75, 0.9, 1.0]
    for n in [10_000, 100_000, 500_000]:
        r = evaluate(n, depths)
        passed = sum(1 for v in r.values() if v)
        print(f"{n:>8} tokens: {passed}/{len(depths)} positions passed")

Liên hệ và so sánh

Liên hệ các chủ đề: Long context kết nối chặt với KV cache, state-space models , và inference optimization . Trong thực tế, long context luôn đi kèm RAG ở phần pipeline dữ liệu đầu vào.

Bảng so sánh nhanh các lựa chọn tiếp cận tài liệu dài cho một query:

Tiếp cậnĐiểm mạnhĐiểm yếuKhi dùng
Long context thuầnĐơn giản, reasoning xuyên tài liệuĐắt, lost-in-the-middle< 200K tokens, 1 query
Long context + cachingRẻ hơn 5-10x khi query lặpCache timeout 5 phút (ephemeral)200K-2M tokens, nhiều query
RAG thuầnScale tới tỷ documents, rẻPhụ thuộc chất lượng retrieval> 10M tokens, freshness cao
Hybrid (RAG → LC)Cân bằng scale + chất lượngComplexity cao hơnProduction realistic

Tóm tắt

  • Long context: từ 4K (2023) đến 1M tokens (2025) — đọc cả cuốn sách trong 1 lần.
  • KV cache là bottleneck chính: tăng tuyến tính với seq_len, có thể lớn hơn model weights.
  • Attention vẫn O(N²) FLOPs: Flash Attention giảm memory O(N), SSM giảm FLOPs thực sự.
  • 'Lost in the middle': model nhớ tốt đầu/cuối, yếu ở giữa; cần RULER/LongBench để đánh giá.
  • Prompt caching giảm chi phí query lặp 5-10x: prefix không đổi → KV cache tái sử dụng.
  • Long context vs RAG là complementary: dưới 200K dùng long context, trên 2M dùng RAG; ở giữa hybrid.

Continue the module

Lesson 3 of 6