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
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
Đí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.
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)
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
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
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
importanthropicclient=anthropic.Anthropic()# Đọc toàn bộ tài liệu 500 trangwithopen("contract_500_pages.txt")asf:full_document=f.read()# ~250K tokens# Use prompt caching so re-asking is cheapresponse=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-upforblockinresponse.content:ifblock.type=="text":print(block.text)print("\nUsage:",response.usage)
Đo tokens và chia nhỏ khi vượt context
importanthropicfromdataclassesimportdataclassclient=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).# ----------------------------------------------------------------------------defcount_tokens(text:str,model:str=MODEL)->int:resp=client.messages.count_tokens(model=model,messages=[{"role":"user","content":text}],)returnresp.input_tokensdeffits_in_context(text:str,budget:int=180_000)->bool:"""Reserve ~20K tokens cho system prompt + response."""returncount_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.# ----------------------------------------------------------------------------@dataclassclassChunk:text:strtokens:intindex:intdefchunk_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=0forpinparagraphs:toks=count_tokens(p)ifcurrent_toks+toks>chunk_tokensandcurrent:chunks.append(Chunk(text="\n\n".join(current),tokens=current_toks,index=len(chunks),))current=[p]current_toks=tokselse:current.append(p)current_toks+=toksifcurrent:chunks.append(Chunk(text="\n\n".join(current),tokens=current_toks,index=len(chunks),))returnchunks# ----------------------------------------------------------------------------# Strategy selector — chọn long context / hybrid / RAG theo kích thước# ----------------------------------------------------------------------------defchoose_strategy(doc_path:str)->str:withopen(doc_path)asf:text=f.read()tokens=count_tokens(text)iftokens<180_000:return"long-context-single-call"iftokens<900_000:return"long-context-with-caching"iftokens<10_000_000:return"hybrid-retrieval-plus-long-context"return"pure-rag"# ----------------------------------------------------------------------------# Example run — áp dụng chiến lược đã chọn# ----------------------------------------------------------------------------defanalyze(doc_path:str,question:str)->str:strategy=choose_strategy(doc_path)text=open(doc_path).read()ifstrategy=="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}",}],)returnresp.content[0].textifstrategy=="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}],)returnresp.content[0].text# hybrid or pure RAG: embed + top-K retrieval, omitted for brevityraiseNotImplementedError(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'.
"""importanthropicimportrandomimportstringclient=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.")defmake_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]definject_needle(haystack:str,depth:float)->str:pos=int(len(haystack)*depth)returnhaystack[:pos]+"\n\n"+NEEDLE+"\n\n"+haystack[pos:]defask(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:"),}],)returnresp.content[0].text.strip()defevaluate(n_tokens:int,depths:list[float])->dict[float,bool]:haystack=make_haystack(n_tokens)results:dict[float,bool]={}fordindepths:doc=inject_needle(haystack,d)answer=ask(doc)results[d]="LOVELACE-1815"inanswerreturnresults# Example runif__name__=="__main__":depths=[0.0,0.1,0.25,0.5,0.75,0.9,1.0]fornin[10_000,100_000,500_000]:r=evaluate(n,depths)passed=sum(1forvinr.values()ifv)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ếu
Khi 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 + caching
Rẻ hơn 5-10x khi query lặp
Cache timeout 5 phút (ephemeral)
200K-2M tokens, nhiều query
RAG thuần
Scale 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ượng
Complexity cao hơn
Production 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.