Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.
Cấu trúc tổng thể của một AI Agent, bao gồm các thành phần cốt lõi: nhận thức, suy luận, bộ nhớ và hành động.
lesson94 minRAG & AgentsAI Engineer
Dự đoán
Một AI Agent thật sự cần 4 thành phần cốt lõi: LLM (bộ não suy luận), Memory (bộ nhớ ngắn + dài hạn), Tools (hành động ra thế giới thực), Planning (chia bài toán + phản ánh). Thiếu bất kỳ thành phần nào Agent sẽ bị giới hạn nghiêm trọng trong các nhiệm vụ nhiều bước.
Khám phá
Thành phần
Vai trò
LLM
Phân tích yêu cầu người dùng, suy luận từng bước, quyết định gọi công cụ nào và tổng hợp kết quả cuối cùng.
Bộ nhớ ngắn hạn
Lưu trữ thông tin trong phiên hiện tại: lịch sử hội thoại, kết quả tool call, ghi chú trung gian. Bị giới hạn bởi context window của LLM.
Bộ nhớ dài hạn
Lưu trữ vĩnh viễn: sở thích người dùng, các chuyến đi trước, kiến thức miền. Truy vấn qua embedding + semantic search.
Công cụ
Các hành động Agent có thể thực hiện: gọi API, truy vấn DB, chạy code, duyệt web, gửi email. Mỗi tool có schema rõ ràng (tên, tham số, mô tả).
Lập kế hoạch
Chia bài toán lớn thành chuỗi bước nhỏ, giám sát tiến độ, phát hiện lệch hướng và điều chỉnh (replan) khi cần.
Khoảnh khắc aha
AI Agent không phải là LLM được bọc thêm API — nó là một hệ thống nhận thức-hành động có vòng lặp kiểu ReAct: nhận thức → suy luận → hành động (qua function calling) → quan sát → điều chỉnh. Khi có nhiều Agent cùng chạy, ta thêm một tầng điều phối. Giống như con người giải quyết vấn đề: ta không chỉ nghĩ, mà còn làm, nhìn kết quả rồi thay đổi cách làm.
Thử thách 1
Planning chia 3 bước (search → summarize → email). Tools thực hiện search web và send email. LLM tóm tắt và suy luận. Memory lưu kết quả tìm kiếm để tổng hợp ở bước cuối. Thiếu Memory → Agent mất ngữ cảnh giữa các lần gọi tool.
Lý thuyết
Kiến trúc Agent hiện đại gồm 4 thành phần cốt lõi hoạt động trong vòng lặp liên tục, còn gọi là agentic loop. Mỗi thành phần có chức năng riêng biệt nhưng phải phối hợp chặt chẽ thông qua một giao thức chung (thường là JSON messages).
LLM (bộ não): Trung tâm suy luận. Nhận input từ người dùng + context từ bộ nhớ + kết quả từ công cụ → đưa ra quyết định tiếp theo. Thường là GPT-4, Claude, hay Gemini.
Bộ nhớ: Chia hai tầng. Ngắn hạn là context window + scratchpad JSON. Dài hạn là vector DB (Pinecone, Weaviate, pgvector) truy cập qua embedding.
Công cụ: Mở rộng khả năng hành động — search web, code execution, API calls, DB queries, trình duyệt, file system. Mô tả bằng JSON Schema để LLM biết cách gọi.
Lập kế hoạch: Task decomposition + reflection + self-correction. Biến nhiệm vụ phức tạp thành chuỗi bước khả thi và giữ Agent đi đúng hướng.
Mối liên hệ toán học giữa các thành phần có thể biểu diễn dạng state transition:
st+1=f(st,at,ot)
trong đó st là trạng thái Agent ở bước t (bao gồm memory), at là hành động (tool call) được LLM chọn, ot là quan sát (kết quả tool), và f là hàm chuyển trạng thái của môi trường. Đây là hệ thống Markov Decision Process (MDP) quen thuộc trong Reinforcement Learning .
agent_architecture.py (LangGraph)
# Pseudocode dùng LangGraph để triển khai vòng lặp Agent 4 phafromtypingimportTypedDict,Annotatedfromlanggraph.graphimportStateGraph,ENDfromlangchain_openaiimportChatOpenAIfromlangchain_core.toolsimporttoolclassAgentState(TypedDict):"""Trạng thái được chuyền qua các pha"""user_request:strplan:list[str]current_step:inttool_results:list[dict]long_term_memory:dictfinal_answer:str|Nonellm=ChatOpenAI(model="gpt-4o",temperature=0)@tooldefsearch_flights(origin:str,destination:str,date:str,max_price:int)->list[dict]:"""Tìm chuyến bay theo tuyến và ngân sách."""# Giả lập gọi APIreturn[{"id":"VN-301","price":12000000,"airline":"VietnamAirlines"}]@tooldefbook_flight(flight_id:str,passenger:dict)->dict:"""Đặt vé và trả về mã xác nhận."""return{"confirmation":"ABC123","flight_id":flight_id}TOOLS=[search_flights,book_flight]# ── Pha 1: Perceive ────────────────────────────────────────────────────────defperceive(state:AgentState)->AgentState:# Chuẩn hoá yêu cầu thô của người dùng thành intent rõ ràng.prompt=f"Parse intent và extract entities từ: {state['user_request']}"parsed=llm.invoke(prompt)state["user_request"]=parsed.contentreturnstate# ── Pha 2: Plan ─────────────────────────────────────────────────────────────defplan(state:AgentState)->AgentState:# Tham chiếu long-term memory để cá nhân hoáprefs=state["long_term_memory"].get("flight_prefs",{})plan_prompt=(f"Tạo kế hoạch 3-5 bước để hoàn thành: {state['user_request']}. "f"Sở thích người dùng: {prefs}. "f"Công cụ khả dụng: {[t.name for t in TOOLS]}")response=llm.invoke(plan_prompt)state["plan"]=response.content.split("\n")state["current_step"]=0returnstate# ── Pha 3: Act ──────────────────────────────────────────────────────────────defact(state:AgentState)->AgentState:step=state["plan"][state["current_step"]]# LLM chọn tool + tham số, sau đó ta executellm_with_tools=llm.bind_tools(TOOLS)tool_call=llm_with_tools.invoke(f"Thực hiện bước: {step}")forcallintool_call.tool_calls:matched=next(tfortinTOOLSift.name==call["name"])result=matched.invoke(call["args"])state["tool_results"].append({"step":step,"result":result})state["current_step"]+=1returnstate# ── Pha 4: Reflect ──────────────────────────────────────────────────────────defreflect(state:AgentState)->AgentState:recent=state["tool_results"][-1]critique_prompt=(f"Kết quả bước vừa rồi: {recent}. "f"Đã hoàn thành yêu cầu '{state['user_request']}' chưa? ""Nếu chưa, có cần thay đổi kế hoạch không?")verdict=llm.invoke(critique_prompt)if"hoàn thành"inverdict.content.lower():state["final_answer"]=verdict.contentreturnstatedefroute_next(state:AgentState)->str:ifstate["final_answer"]isnotNone:returnENDifstate["current_step"]>=len(state["plan"]):return"plan"# Replan nếu hết bước mà chưa xongreturn"act"# ── Lắp ráp đồ thị ──────────────────────────────────────────────────────────graph=StateGraph(AgentState)graph.add_node("perceive",perceive)graph.add_node("plan",plan)graph.add_node("act",act)graph.add_node("reflect",reflect)graph.set_entry_point("perceive")graph.add_edge("perceive","plan")graph.add_edge("plan","act")graph.add_edge("act","reflect")graph.add_conditional_edges("reflect",route_next,{"act":"act","plan":"plan",END:END,})agent=graph.compile()result=agent.invoke({"user_request":"Đặt vé TP.HCM → Tokyo ngày 2/5, dưới 15 triệu","plan":[],"current_step":0,"tool_results":[],"long_term_memory":{"flight_prefs":{"airline":"VietnamAirlines"}},"final_answer":None,})
agent_architecture_crewai.py (CrewAI — cách tiếp cận declarative)
# CrewAI cho bạn định nghĩa Agent ở mức cao hơn, không cần tự viết graph.fromcrewaiimportAgent,Task,Crew,Processfromcrewai.memoryimportShortTermMemory,LongTermMemoryfromcrewai_toolsimportSerperDevToolsearch_tool=SerperDevTool()# ── Định nghĩa Agent ─────────────────────────────────────────────────────flight_planner=Agent(role="Flight Planner",goal="Đặt vé máy bay đúng ngân sách và sở thích người dùng",backstory=("Bạn là chuyên gia đặt vé với 10 năm kinh nghiệm. ""Ưu tiên chất lượng, giá, và sở thích người dùng trong thứ tự đó."),tools=[search_tool],memory=True,short_term_memory=ShortTermMemory(),long_term_memory=LongTermMemory(),allow_delegation=False,verbose=True,max_iter=8,# max_steps — chặn loop vô hạnmax_rpm=20,# rate limit API)# ── Định nghĩa Task ──────────────────────────────────────────────────────book_task=Task(description=("Tìm vé TP.HCM → Tokyo ngày 2/5, dưới 15 triệu, ưu tiên Vietnam Airlines. ""Nếu không tìm thấy, đề xuất 2 giải pháp thay thế."),expected_output="Mã xác nhận đặt vé hoặc 2 giải pháp thay thế có giải thích.",agent=flight_planner,human_input=False,# Bật True nếu muốn hỏi xác nhận)# ── Crew: khung Agent + Task ────────────────────────────────────────────crew=Crew(agents=[flight_planner],tasks=[book_task],process=Process.sequential,memory=True,verbose=True,)result=crew.kickoff()print(result)
Vai trò thực của Memory
Nhiều bài blog đơn giản hoá Agent thành "LLM + Tool", nhưng khi Agent chạy nhiều bước, context window (khoảng 128K tokens) nhanh chóng đầy lên vì chứa: lịch sử hội thoại, mô tả tool, kết quả tool, suy luận CoT. Không có bộ nhớ dài hạn, Agent quên sở thích người dùng sau vài phiên. Không có scratchpad, Agent lặp lại công việc đã làm. Không có vector search, Agent không tìm lại được thông tin từ tuần trước.
Giải pháp chuẩn: tách working memory (scratchpad JSON trong khung chạy hiện tại), episodic memory (các phiên trước, lưu dạng chunk + embedding), và semantic memory (kiến thức nền, profile người dùng, domain facts). Mỗi loại dùng công cụ khác nhau để truy xuất — nên kiến trúc Agent thực sự là "LLM + Tools + Memory(3 tầng) + Planning".
Agentic loop vs ReAct vs Plan-and-Execute
ReAct (Reasoning + Acting, Yao et al. 2022) là biến thể đơn giản: mỗi bước Agent sinh một đoạn suy nghĩ (Thought) rồi một hành động (Action). Ưu điểm: minh bạch, dễ debug. Nhược: ra quyết định ngắn hạn, khó nhìn trước nhiều bước.
Plan-and-Execute (Wang et al. 2023) tách biệt pha lập kế hoạch (sinh toàn bộ kế hoạch trước) và pha thực thi (chạy từng bước). Ưu: kế hoạch ổn định, dễ optimise. Nhược: kế hoạch có thể lỗi thời khi môi trường thay đổi.
Agentic loop 4 pha (Perceive → Plan → Act → Reflect) mà bài này trình bày là tổng quát hoá: bạn có thể cấu hình độ dài mỗi pha, cho phép replan sau reflect, và kết hợp cả ReAct (ngắn hạn) lẫn Plan-and-Execute (dài hạn). Framework như LangGraph, CrewAI, AutoGen đều xây trên mẫu này.
Khi nào chọn cái nào? Bài toán ngắn (≤5 bước, môi trường ổn định) → ReAct là đủ và nhẹ. Bài toán dài, cấu trúc rõ (research pipeline, ETL) → Plan-and-Execute cho sự ổn định. Bài toán động, có fail giữa chừng (customer support, trading) → loop 4 pha với reflect mạnh để tự sửa.
Ba loại bộ nhớ Agent
Working memory (scratchpad): một object JSON được chuyền qua các pha trong một phiên. Chứa plan hiện tại, tool results, ghi chú trung gian. Hết phiên là mất. Dùng trực tiếp trong context window.
Episodic memory: lịch sử các phiên trước được chunk hoá + embed, lưu vector DB (Pinecone, Weaviate, pgvector). Khi cần, Agent query theo semantic similarity để lấy các episode liên quan. Ví dụ: "tháng trước user đặt vé đi Tokyo, đã thích chuyến sáng sớm".
Semantic memory: kiến thức nền (domain facts, profile người dùng, business rules). Có thể cấu trúc hoá (knowledge graph, SQL) hoặc dạng tài liệu (markdown, vector DB). Cập nhật chậm, đọc nhiều.
Thực tế, một Agent production thường có đủ cả 3: working memory trong state graph, episodic memory qua Pinecone, semantic memory qua Postgres + pgvector. Phần khó nhất là memory routing — quyết định nhớ/quên gì ở tầng nào.
Chi phí và latency
Một Agent 4 pha trên GPT-4o, xử lý nhiệm vụ 5 bước, tiêu thụ trung bình khoảng 15K–40K tokens. Với giá 2024 (số liệu theo nguồn bài, chưa kiểm chứng) (~$5/1M input, $15/1M output), một phiên hoàn thành tốn khoảng $0.15 – $0.40. Nhân lên 10K phiên/ngày = chi phí LLM $1.5K – $4K/ngày.
Latency: pha Plan (CoT) nặng nhất ~2–4s. Pha Act phụ thuộc tool (DB query ~100ms, web scrape ~2s, code sandbox ~5s). Tổng phiên 5 bước thường 15–40 giây. Kỹ thuật giảm: KV cache, streaming response, chạy song song các tool độc lập trong 1 pha Act.
Tối ưu chi phí: dùng mô hình nhỏ (GPT-4o-mini, Claude Haiku) cho các bước đơn giản (parse, classify) và model lớn chỉ khi cần suy luận phức tạp. Kiến trúc "cascade" này có thể giảm 70–80% chi phí mà giữ chất lượng gần tương đương.
Các điểm then chốt
Thử thách 2
Reflect là pha so sánh kết quả thực tế với mục tiêu. Tại đây Agent quyết định: kết quả đủ tốt → dừng và trả lời; kết quả chưa đủ → quay lại Plan với chiến lược mới; hoặc thực hiện thêm Act nếu chỉ thiếu một tool call đơn giản.
Tóm tắt
4 thành phần cốt lõi: LLM (bộ não suy luận), Memory (ngắn hạn context + dài hạn vector DB), Tools (API/code/DB — mô tả bằng JSON Schema), Planning (chia bước + reflection).
Agent hoạt động theo vòng lặp 4 pha: Perceive (nhận thức) → Plan (lập kế hoạch) → Act (hành động) → Reflect (phản ánh) → lặp lại.
Khác chatbot: Agent TỰ CHỦ thực hiện nhiều bước với môi trường thực, thay vì chỉ phản hồi 1 lượt hội thoại.
Long-term memory qua vector DB cho phép Agent nhớ sở thích người dùng xuyên phiên; short-term dùng context window cho phiên hiện tại.
Bẫy phổ biến: loop vô hạn, gọi sai tool, mất ngữ cảnh. Luôn có max_steps, guardrails, và logging từng bước.
Framework chuẩn: LangGraph (graph-based, rõ state), CrewAI (declarative role/task), AutoGen (multi-agent chat) — chọn theo nhu cầu cụ thể.
Đi tiếp
Bạn đã nắm kiến trúc tổng thể — bước tiếp theo:
Học cách Agent chọn tool qua function calling.
Đi sâu vào Planning — chiến lược chia bài toán lớn.
Khám phá Memory Systems với 3 tầng: working, episodic, semantic.
Xem các mẫu workflow ở Agentic Workflows.
Khi có nhiều Agent, bạn sẽ cần Multi-Agent + Orchestration.
Danh sách kiểm tra trước khi triển khai Agent lên production:
Giới hạn bước:max_iter hoặc recursion_limit được set cụ thể, không để mặc định vô tận.
Sandbox: mọi tool thực thi code phải chạy trong container cô lập (Docker, Firecracker, gVisor), không bao giờ chạy trực tiếp trên máy chủ chính.
Allowlist: tool gọi API phải chỉ được phép truy cập domain đã whitelist, không mở rộng ra toàn bộ internet.
Audit log: mỗi tool call + tham số + kết quả ghi vào log có thể truy vết — tối thiểu 30 ngày.
Human-in-the-loop: các hành động không đảo ngược (send email, charge payment, delete file) phải chờ confirmation trước khi thực thi.
Budget guard: theo dõi tổng token + tổng chi phí theo phiên. Tự ngắt khi vượt ngưỡng để tránh "cost explosion".
Test harness: viết test giả lập môi trường (mock tools) để Agent có thể được kiểm thử regression mỗi khi prompt hay model thay đổi.
Observability: dùng LangSmith, Langfuse hoặc Arize — trực quan hoá graph run, xem token flow, đánh giá chất lượng qua LLM judge.
Case study nhỏ để luyện tập:
Personal research assistant: Agent nhận câu hỏi nghiên cứu, tự tìm 5 nguồn, tóm tắt, và xuất bản tóm tắt markdown. Cần: search tool, read tool, memory để tránh đọc trùng, reflection để đánh giá chất lượng tóm tắt.
Helpdesk Agent: đọc ticket, phân loại, tham chiếu KB (vector DB), đề xuất giải pháp, chuyển ticket khó cho người thật. Cần: memory dài hạn (KB), memory ngắn hạn (ticket context), tool gọi CRM.
Data analysis Agent: nhận câu hỏi dữ liệu, tự viết SQL, chạy, kiểm tra kết quả bất thường, vẽ biểu đồ. Cần: code execution tool (sandbox), vector DB schema, reflection để phát hiện bug SQL.