S-02 · TALK SHOW LLM TO AGENTIC

Vòng đời Context
& LLM

Bóc tách cái mà LLM thực sự "nhìn thấy" trong mỗi turn — và cách điều khiển nó.

Buổi 2 — Chúng ta sẽ đi qua gì?
💬

01 · Context là gì?

3 vai trò: System / User / Assistant — & nguyên lý "stateless"

📂

02 · Anatomy của Context Window

Always / On-demand / Variable / Buffer — token economics

🔄

03 · Vòng đời

Birth → Grow → Compact → Death (autocompact)

💾

04 · Persistence — nhét gì vào đâu?

Project rules · Skills · Workflows · Subagents · Hooks · Output styles

🎯

05 · Context Engineering

5 nguyên tắc, anti-patterns, cách debug

01

Context — Cái LLM
thực sự "nhìn thấy"

3 vai trò trong một cuộc chat

LLM = mô hình ngôn ngữ dự đoán token tiếp theo

Mỗi lần gọi API, ta gửi toàn bộ context. Model không nhớ phiên trước — nhớ là việc của ta.

System

Định hình hành vi AI

You are a senior backend engineer...
Tools: Read · Write · Bash
Tone: ngắn gọn, không emoji

User

Yêu cầu của con người

"Refactor hàm parseConfig thành 3 hàm nhỏ và viết unit test."

Assistant

Phản hồi + tool calls

"Đã đọc file. Phân tách thành parseHeader, parseBody, parseFooter. Đang viết test..."

Mỗi turn nối tiếp nhau theo thứ tự thời gian. Toàn bộ chuỗi này gọi là context window.

Quan trọng: API stateless

Ngộ nhận phổ biến

"Tôi nói với ChatGPT/Claude tuần trước, chắc nó nhớ."

Nhiều bạn nghĩ model có "trí nhớ" liên phiên — như con người.

❌ Sai. Mỗi request API là độc lập. Model không có ổ đĩa lưu cuộc chat.

➔

Thực tế

UI (ChatGPT, Claude.ai, Cursor…) gửi lại toàn bộ lịch sử mỗi turn.

Cảm giác "nhớ" = client side replay history vào prompt.

✅ Muốn agent "nhớ" xuyên phiên → ta phải persist ra ngoài (DB, file, vector store).

Hệ quả thiết kế: memory ngắn hạn = nằm trong context, memory dài hạn = ngoài context, ta tự load lại khi cần.

02

Anatomy của
Context Window

4 nhóm thành phần trong context window
Thành phần Nhóm Tokens (ví dụ) % Mô tả
ALWAYS INCLUDED — luôn nạp khi bắt đầu phiên
System Prompt ALWAYS 3,2001.6% Hành vi, tone, safety rules, output format mặc định.
Tool Definitions ALWAYS 11,6005.8% Schema của tool nội tại: Read, Write, Edit, Bash, Grep, Glob…
Project Memory (CLAUDE.md / .cursorrules / GEMINI.md) ALWAYS 8000.4% Instruction project-level: build cmd, convention, kiến trúc.
ON-DEMAND — chỉ load khi cần / khi invoke
MCP Tools ON-DEMAND 3,0001.5% Tool external qua MCP: GitHub, Slack, Postgres, …
Skills / Slash commands ON-DEMAND 1,2000.6% name + description load ngay, body chỉ load khi invoke (/commit, /review).
Subagents ON-DEMAND 8000.4% "Trợ lý phụ" với context riêng — chỉ thông tin tóm tắt trả về.
VARIABLE (per session) — tăng dần theo cuộc chat
Messages history VARIABLE 16,0008.0% Lịch sử trao đổi (~15–20 turn cuối).
File contents VARIABLE 12,0006.0% File đã Read trong session (~5 file source).
Tool / Bash outputs VARIABLE 4,0002.0% Kết quả build, test, grep, … (rất ăn token).
Extended thinking VARIABLE 16,0008.0% Reasoning nội bộ (lên tới 32k với model có thinking budget).
BUFFER
Free space AVAILABLE 88,40044.2% Phần trống còn lại để tiếp tục cuộc chat.
Autocompact buffer RESERVED 45,00022.5% Khi chạm ngưỡng → trigger nén lịch sử để tạo chỗ trống.
Ví dụ model 200,000 tokens · 68,600 / 200,000 đã dùng (34.3%)
Hình dung 1 context window 200k tokens
SYS 7.5%
TOOL
CHAT 8%
FILES + BASH 16%
COMPACT BUFFER 22%
FREE 44%
SYS + Tools (always)
Skills (on-demand)
Messages
Files + outputs
Autocompact buffer
Free space

✅ Phần "luôn cố định"

System prompt + tool defs + project memory chiếm ~8%. Đây là chi phí "thuê chỗ" cố định mỗi turn.

🔥 Phần "biến động"

Càng nhiều turn / file / bash output → càng phình. Đa số sự cố cost & latency đến từ đây.

⚠ Vùng đỏ (compact)

Khi context dùng tới ~78%, model bắt đầu nén lịch sử cũ → có thể "ăn mất" thông tin quan trọng.

03

Vòng đời 4 pha
Birth → Grow → Compact → Death

Vòng đời một context
1
🌍 Birth — Session start

Load System prompt + Tool definitions + Project memory (CLAUDE.md / .cursorrules) + Skill names & descriptions. Context bắt đầu ở ~5–10%.

2
🌱 Grow — Each turn

Mỗi turn nối thêm: user message → assistant message + (optional) tool calls + tool results. Mỗi Read file / Bash output có thể thêm hàng nghìn tokens.

3
🔥 Compact — Khi chạm ngưỡng

Khi context dùng ~78%, hệ thống tự động nén: tool outputs cũ bị xoá, hội thoại được tóm tắt. Vẫn giữ system prompt + project memory.

4
☠ Death — Session end

Khi đóng session, toàn bộ context biến mất. Mọi thứ ta muốn nhớ phải đã được persist ra ngoài (file, DB, vector store, commit, …).

Trong agent dài hạn, compact & death là 2 sự kiện ta phải thiết kế xung quanh, không phải "tai nạn".

04

Persistence —
Nhét gì vào đâu?

Project memory — File "luôn được đọc"

Khái niệm chung

Mỗi hệ thống agent (Claude Code, Cursor, Gemini CLI, Aider, …) đều có một file markdown root được tự động nạp vào system prompt mỗi session.

Nó dùng để chứa gì?

  • Cách chạy & build project (lệnh, ENV).
  • Cấu trúc thư mục & module.
  • Coding convention, naming, lint.
  • Ràng buộc: "đừng làm X", "luôn dùng Y".
  • Quy ước commit, PR.

Giữ ngắn (< 1k tokens lý tưởng) — nó nằm trong "always-in" nên mỗi byte = chi phí mỗi turn.

Các "tên gọi" khác nhau

project root
# Tuỳ hệ agent, file root khác tên: CLAUDE.md # Claude Code .cursorrules # Cursor (legacy) .cursor/rules # Cursor (modern) AGENTS.md # OpenAI Codex CLI / Aider GEMINI.md # Gemini CLI .aider.conf.yml # Aider # Tất cả đều phục vụ cùng 1 mục tiêu: # "instruction cố định kèm theo mọi prompt"

Mẹo dùng tốt

  • Viết như onboarding doc cho dev mới.
  • Tách rule path-scoped cho thư mục cụ thể.
  • Update định kỳ — coi như "code".
3 cơ chế "lazy load" — Giảm bloat context
Skill

Skill / Slash command

Thư mục chứa hướng dẫn chi tiết cho 1 tác vụ (vd: /commit, /review, /debug).

Khi session start: chỉ tên + mô tả ngắn được load. Body chỉ vào context khi user gọi.

Lý tưởng cho task lặp lại có quy trình rõ.

+
Subagent

Subagent / Worker

"Trợ lý phụ" chạy trong context riêng. Có system prompt, tool allow-list, model riêng.

Agent chính chỉ thấy kết quả tóm tắt trả về — không bị ảnh hưởng bởi noise của subagent.

Lý tưởng cho search rộng, research, side-task lớn.

+
MCP

MCP Server

Tool external (GitHub, Slack, Postgres, Figma…) qua giao thức chuẩn JSON-RPC.

Khai báo trong settings.json. Schema tool load khi server kết nối — vẫn tốn context.

Bật/tắt theo nhu cầu để tránh "ngạt tool".

Nguyên tắc: chỉ load khi cần. 50 skills × 2k tokens body = 100k tokens — không bao giờ nhét tất cả vào always-in.

Workflow — Chuỗi nhiều bước có thứ tự

Workflow vs Skill

Skill = 1 tác vụ cohesive (vd: /commit, /review).
Workflow = nhiều bước có thứ tự, mỗi bước có thể là 1 skill, 1 tool, hoặc 1 subagent — kèm gate giữa các bước.

Cấu trúc 4 phase điển hình

  1. 1 Understand — đọc request, scan code, hỏi cái cần.
  2. 2 Implement — code/edit theo plan.
  3. 3 Verify — chạy test, lint, build.
  4. 4 Review — review nội bộ + cập nhật docs.

Đây là "khung xương" — bạn nhân lên / cắt bớt theo loại task (bug-fix, feature, refactor, doc…).

Một workflow gồm 3 cấu phần

A
Rules (workflow routing)

"Khi user nói X → chạy workflow Y." Logic chọn workflow nào.

B
Steps (skills / subagents)

Mỗi phase = invoke một skill hoặc subagent. Có input/output rõ ràng.

C
Gates (hooks)

Hook chặn nếu artifact yêu cầu chưa có. Vd: không qua Implement nếu chưa có plan file.

Skill = 1 hành động · Workflow = chuỗi nhiều skill + ràng buộc thứ tự + gate.

Workflow ví dụ: "Sửa 1 bug từ A → Z"

Routing (rule)

User: "Sửa bug bộ lọc lỗi khi date trống."
↓ matched bug-fix-workflow (rule).

Phases (mỗi phase 1 skill / subagent)

1 Reproduce — viết test fail trước skill: /tdd 2 Diagnose — chạy debugger, đọc trace subagent: debugger 3 Fix — sửa code, test passes skill: /edit 4 Verify — full test, lint, typecheck skill: /verify 5 Commit + PR skill: /commit

Gates (hooks)

workflow-artifact-gate.cjs
// Hook: PostToolUse // Mục tiêu: không cho phase 3 (Fix) chạy // nếu phase 1 chưa tạo file test. if (phase() === "fix") { if (!existsSync("tests/bug-XXXX.spec.ts")) { block({ reason: "Phải có failing test trước khi fix.", suggest: "Chạy /tdd reproduce trước." }); } }

Lợi ích so với chat tự do

  • Quy trình nhất quán giữa các thành viên team.
  • Mỗi phase có output rõ ràng → dễ review.
  • Agent không skip bước dù model "thông minh".
  • Tách context từng phase → giảm bloat.
Hooks — Tự động hoá ngoài LLM

Định nghĩa

Hook = script / command được chạy tự động khi có sự kiện nhất định trong vòng đời session. Không tốn token, không cần model "nhớ" gọi nó.

Các sự kiện điển hình

  • SessionStart — Khi mở session.
  • UserPromptSubmit — Khi user gửi tin.
  • PreToolUse — Trước khi model gọi tool.
  • PostToolUse — Sau khi tool xong.
  • Stop — Khi agent kết thúc.

Hook = deterministic. LLM = probabilistic. Khi cần chắc chắn 100% → dùng hook.

Ví dụ thực tế

PostToolUse: chạy lint sau khi Edit
// settings.json { "hooks": { "PostToolUse": [{ "matcher": "Edit|Write", "command": "pnpm lint --fix $CLAUDE_FILE_PATH", "timeout": 30000 }], "PreToolUse": [{ "matcher": "Bash", "command": "./check-safe-cmd.sh" }] } }

Khi nào dùng hook?

  • Chặn lệnh nguy hiểm (rm -rf, force push).
  • Format / lint sau khi sửa file.
  • Notify Slack khi session done.
  • Inject context động (vd: ngày giờ hiện tại).
Bản đồ cơ chế persist — "Đặt thông tin vào đâu?"
Cơ chế Sống bao lâu? Tốn token? Khi nào dùng
System prompt Cả phiên Mỗi turn Định nghĩa vai trò và safety rules.
Project rules (CLAUDE.md / AGENTS.md / .cursorrules) Cả phiên Mỗi turn Context không đổi theo project: convention, kiến trúc.
Skill / Slash command Một phần phiên (khi invoke) On-demand Một tác vụ cohesive (1 lệnh = 1 action). Vd: /commit.
Workflow Một phần phiên (chuỗi) On-demand Chuỗi nhiều skill/subagent với phase & gate. Vd: bug-fix, feature.
Subagent 1 task Context riêng Task lớn / search rộng → tránh làm phình agent chính.
Hook Trigger theo sự kiện 0 (chạy ngoài LLM) Cần chắc chắn & deterministic.
Output style Cả phiên Mỗi turn Đổi tone / format trả lời (vd: terse, teacher, JSON).
Memory layer (vector DB, file) Liên phiên Khi load lại Cá nhân hoá & học liên phiên (sẽ học ở S-09).

Câu hỏi vàng khi thiết kế agent: "Thông tin này luôn cần, hay chỉ khi user hỏi?" — Quyết định nó nằm ở always-in hay on-demand.

Layout thư mục mẫu cho 1 agent project

Cấu trúc điển hình

my-project/ ├── CLAUDE.md # project memory (always) ├── .claude/ │ ├── rules/ # path-scoped rules │ │ ├── backend.md │ │ └── frontend.md │ ├── skills/ # 1 lệnh = 1 action │ │ ├── commit/ │ │ │ └── SKILL.md │ │ ├── review-pr/ │ │ └── debug-test/ │ ├── workflows/ # chuỗi nhiều bước có gate │ │ ├── bug-fix.md │ │ ├── new-feature.md │ │ └── refactor.md │ ├── agents/ # subagents │ │ ├── code-reviewer.md │ │ ├── researcher.md │ │ └── tester.md │ ├── hooks/ # automation │ │ ├── pre-bash.sh │ │ └── post-edit.sh │ ├── output-styles/ │ │ └── terse.md │ └── settings.json # MCP servers, perms └── src/ ...

Trade-off khi tổ chức

  • CLAUDE.md ngắn, ưu tiên đẩy chi tiết về rules/ để load có chọn lọc.
  • Skills cho quy trình lặp lại; Subagents cho task có "thế giới riêng".
  • Hooks cho quy tắc an toàn (chặn rm -rf, force push, lộ secret).
  • MCP bật theo nhu cầu, không bật all-or-nothing.
  • Mọi config checked-in git để team dùng chung & reproducible.

Layout này giống nhau (về ý) cho Claude Code, Cursor, Gemini CLI — chỉ khác tên thư mục.

05

Context Engineering
5 nguyên tắc thực chiến

5 nguyên tắc khi thiết kế context
🎯

1 · Relevance > Volume

Context ngắn + đúng > context dài. Mỗi token thêm vào phải trả lời câu hỏi cụ thể.

📐

2 · Structure > Prose

Bullet, table, JSON, code block dễ scan hơn paragraph. Model "đọc" cấu trúc tốt hơn.

⏳

3 · Fresh-at-bottom

Đặt thông tin quan trọng & mới ở cuối context. Model attend mạnh nhất ở đầu & cuối.

🔥

4 · Compress aggressively

Tool output thô = noise. Lọc, tóm tắt trước khi đưa vào next turn. Subagent là vũ khí mạnh.

💾

5 · Persist outside

Cái gì cần xuyên session → ghi ra file / DB / vector store. Đừng tin vào memory của LLM.

🔍

+ Observe & iterate

Log context thực gửi đi → nhìn xem có rác gì, có lặp gì → tối ưu dần.

Anti-patterns thường gặp

❌ Sai lầm phổ biến

"CLAUDE.md 5,000 dòng" — nhét toàn bộ wiki vào → bloat 30%+ context mỗi turn, cost & latency tăng.

"Bật hết MCP servers" — 20 servers × 50 tools = ngạt schema, model bối rối chọn tool.

"Read cả thư mục để chắc" — đưa 100 files vào context khi chỉ cần grep tên hàm.

"Một mega-prompt" — yêu cầu plan + code + test + commit trong 1 prompt — error propagation.

"Tin model tự nhớ" — không persist ra file → mất sau autocompact.

➔

✅ Cách làm tốt hơn

CLAUDE.md < 1k tokens. Chi tiết → tách rule path-scoped hoặc skill.

MCP bật theo nhu cầu task. Có thể có config preset (dev / debug / docs).

Dùng Grep / Glob tìm trước, Read đúng file cần. Limit lines khi file lớn.

Chia chain of prompt hoặc chain of subagent — sẽ học chi tiết ở S-05.

Cuối phiên → commit code, cập nhật CLAUDE.md, ghi note ra file.

Debug context — "Model thấy gì?"

Lệnh / công cụ có sẵn

  • /context — Claude Code: xem token usage theo từng nhóm.
  • /compact — chủ động nén lịch sử khi đầy.
  • /clear — reset hoàn toàn (giữ project memory).
  • Cursor: Context panel trong settings.
  • LangSmith / Langfuse trace — xem raw request gửi tới LLM.

Checklist khi agent "ngớ ngẩn"

  1. Context đã quá 78%? → vừa nén, có thể mất info.
  2. File quan trọng còn trong context? → thử Read lại.
  3. CLAUDE.md có đúng thông tin? → nhiều khi outdate.
  4. Có conflict giữa rules? → model phải "chọn" → behaviour không ổn định.
  5. Tool output có rác? → filter / tóm tắt trước khi feed.
  6. Đang là phiên dài? → /clear, mở phiên mới.
5 điều nên nhớ
1

LLM API là stateless. Mỗi turn = gửi lại toàn bộ context. Cảm giác "nhớ" là do client replay.

2

Context window có 4 nhóm: ALWAYS · ON-DEMAND · VARIABLE · BUFFER. Hiểu nhóm = quyết được cost & reliability.

3

Vòng đời: Birth → Grow → Compact → Death. Phải thiết kế xung quanh compact & death, không coi là tai nạn.

4

Đặt thông tin đúng chỗ: Project memory (always) · Skill (1 action) · Workflow (chuỗi nhiều bước + gate) · Subagent (context riêng) · Hook (ngoài LLM).

5

Context engineering = Relevance > Volume, structured, fresh-at-bottom, compress, persist outside. Quan sát & lặp.

Bài tập & chuẩn bị buổi 3
📝

Thực hành

  • Viết CLAUDE.md (hoặc .cursorrules) cho 1 repo, < 60 dòng.
  • Tạo 1 skill /commit chuẩn hoá commit message.
  • Thử /context trước & sau khi mở file lớn — đo chênh lệch token.
📚

Đọc trước S-03

  • Sách: Chương "What makes an AI system an Agent?"
  • Lilian Weng: LLM Powered Autonomous Agents (toàn bộ).
  • So sánh: Cursor vs Claude Code vs Aider CLI — chọn 1 để mổ xẻ kiến trúc.
🔗

Tham khảo

  • Anthropic — Steering Claude Code (CLAUDE.md, skills, hooks…).
  • Anthropic — Building Effective Agents.
  • MCP docs — modelcontextprotocol.io.
Hết buổi 2

Buổi 3 — Kiến trúc AI Agent
7 thành phần. So sánh Claude Code · Cursor · OpenAI Assistant · Gemini CLI.

← S-01 Trang chính S-03 ➔