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

Evaluating routing across providers.

Start learning
← RAG & Agents

AI Builder

Kiến trúc Agent — Bộ não của AI tự chủ

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

Bạn muốn xây AI có thể: tìm vé máy bay, so sánh giá, đặt vé, và tự điều chỉnh khi chuyến bị đầy. Agent này cần tối thiểu bao nhiêu thành phầ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ầnVai trò
LLMPhâ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ạnLư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ạnLư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ạchChia 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.
Agent đặt vé cần nhớ 'người dùng thích hãng bay nào' qua nhiều phiên. Thành phần nào lưu thông tin này?

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

Agent được giao: 'Tìm 5 bài báo về AI, tóm tắt mỗi bài, gửi email tổng hợp cho sếp'. Những thành phần nào phải phối hợp?

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)s_{t+1} = f(s_t, a_t, o_t)

trong đó sts_t là trạng thái Agent ở bước tt (bao gồm memory), ata_t là hành động (tool call) được LLM chọn, oto_t là quan sát (kết quả tool), và ff 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 pha
from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

class AgentState(TypedDict):
    """Trạng thái được chuyền qua các pha"""
    user_request: str
    plan: list[str]
    current_step: int
    tool_results: list[dict]
    long_term_memory: dict
    final_answer: str | None

llm = ChatOpenAI(model="gpt-4o", temperature=0)

@tool
def search_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 API
    return [{"id": "VN-301", "price": 12000000, "airline": "VietnamAirlines"}]

@tool
def book_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 ────────────────────────────────────────────────────────
def perceive(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.content
    return state

# ── Pha 2: Plan ─────────────────────────────────────────────────────────────
def plan(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"] = 0
    return state

# ── Pha 3: Act ──────────────────────────────────────────────────────────────
def act(state: AgentState) -> AgentState:
    step = state["plan"][state["current_step"]]
    # LLM chọn tool + tham số, sau đó ta execute
    llm_with_tools = llm.bind_tools(TOOLS)
    tool_call = llm_with_tools.invoke(f"Thực hiện bước: {step}")

    for call in tool_call.tool_calls:
        matched = next(t for t in TOOLS if t.name == call["name"])
        result = matched.invoke(call["args"])
        state["tool_results"].append({"step": step, "result": result})

    state["current_step"] += 1
    return state

# ── Pha 4: Reflect ──────────────────────────────────────────────────────────
def reflect(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" in verdict.content.lower():
        state["final_answer"] = verdict.content
    return state

def route_next(state: AgentState) -> str:
    if state["final_answer"] is not None:
        return END
    if state["current_step"] >= len(state["plan"]):
        return "plan"  # Replan nếu hết bước mà chưa xong
    return "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.
from crewai import Agent, Task, Crew, Process
from crewai.memory import ShortTermMemory, LongTermMemory
from crewai_tools import SerperDevTool

search_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ạn
    max_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

Agent đặt vé đã tìm được 3 chuyến phù hợp trong pha Act. Pha nào tiếp theo chịu trách nhiệm quyết định 'đề xuất cho user hay tìm thêm'?

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:

  1. 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.
  2. 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.
  3. 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.

Continue the module

Lesson 13 of 16