---
title: "AI Agent là gì? Cách AI Agent hoạt động và cách tạo AI Agent với LangGraph"
description: "AI Agent là gì? AI Agent là LLM gọi tool trong vòng lặp tới khi xong việc. Phân biệt agent với workflow, ví dụ và cách tạo AI Agent với LangChain, LangGraph."
canonical: "https://200lab.io/blog/ai-agent-la-gi"
published: "2025-01-18T07:34:04Z"
updated: "2026-10-31T08:41:11Z"
authors: ["Hướng nội"]
tags: ["AI", "Backend"]
reading_minutes: 14
access: "public"
---

Bài viết này trả lời câu hỏi AI Agent là gì dựa theo định nghĩa của OpenAI, Anthropic và LangChain. Mình sẽ giải thích cách agent chạy theo vòng lặp, phân biệt nó với workflow hay chatbot thông thường, rồi hướng dẫn bạn tự tạo một AI Agent nhỏ bằng LangChain và LangGraph với đoạn code đã chạy thật.

## 1. AI Agent là gì?

AI Agent là hệ thống dùng LLM để tự quyết định bước tiếp theo, gọi tool, xem kết quả và lặp lại tới khi xong việc hoặc gặp điều kiện dừng. Theo [tài liệu về agent của LangChain](https://docs.langchain.com/oss/python/langchain/agents), agent đơn giản là một model gọi tool trong vòng lặp cho tới khi hoàn thành nhiệm vụ. Trong [hướng dẫn xây dựng agent của OpenAI](https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/), họ định nghĩa đây là hệ thống thay người dùng hoàn thành công việc một cách độc lập.

Trước khi đi sâu hơn, chúng ta cần nhắc lại về [LLM (Large Language Model)](https://200lab.io/blog/large-language-model-la-gi), thứ hay được ví như "bộ não" đằng sau các AI Agent. Các công cụ quen thuộc như ChatGPT, Gemini hay Copilot cho thấy LLM làm tốt việc đọc hiểu context, tóm tắt tài liệu dài, trích xuất thông tin và suy luận trên ngôn ngữ.

Tuy nhiên, bản thân LLM tự nó chỉ nhận chữ và trả lời chữ. Muốn làm được việc thực tế như tra cứu đơn hàng, đọc file hay gọi API ra ngoài, hệ thống bắt buộc phải gắn thêm tool và đặt vào một vòng lặp.

![LLM là phần bộ não phía sau AI Agent](https://assets.200lab.io/images/2025/01/18/ai-agent-la-gi-llm-a2e486021d5c21d67aaf.webp)

Theo cách gọi của LangChain thì Agent = Model + Harness, trong đó [agent harness](https://200lab.io/blog/agent-harness-la-gi) bao gồm prompt, tool và middleware bao quanh vòng lặp để giữ cho model chạy đúng hướng.

## 2. AI Agent hoạt động như thế nào?

Một agent loop tiêu chuẩn thường diễn ra tuần tự qua 5 bước sau:

1. Nhận yêu cầu đầu vào từ phía người dùng.
2. Model đọc toàn bộ context hiện tại và quyết định nên trả lời luôn hay cần thực hiện tool call.
3. Hệ thống chạy tool được chọn với các tham số do model truyền vào.
4. Đưa kết quả trả về từ tool quay ngược lại vào context để model quan sát.
5. Lặp lại quá trình này cho tới khi model thấy đã đủ thông tin để trả lời xong, hoặc chạm giới hạn số vòng cho phép.

![Agent loop: model quyết định, gọi tool, nhận kết quả rồi lặp lại tới khi xong hoặc chạm giới hạn](https://assets.200lab.io/sha256/82/825484d0a2842d55d61cf1e43f1a3b17635a7e7074e1ecb7929fa2f4f22ed1d1/generations/192a4dd3dd0ff85d72869c92f1cd7bcce1e9d62766af71e3d649c097914cba96)

Kiểu vận hành vòng lặp này bắt nguồn từ [bài báo ReAct của Yao và cộng sự năm 2022](https://arxiv.org/abs/2210.03629). Ý tưởng cốt lõi là cho LLM sinh ra phần reasoning (quá trình model "suy nghĩ" trước khi trả lời) và hành động đan xen nhau. Nhờ vậy, model vừa lập luận, vừa gọi hành động lấy thêm thông tin từ môi trường bên ngoài rồi quan sát kết quả để tính bước kế tiếp.

### 2.1 Các thành phần của một AI Agent

- **Model (LLM):** Thành phần trung tâm đọc context, thực hiện reasoning và ra quyết định chọn bước đi tiếp theo ở mỗi vòng.
- **Tool:** Các hàm hoặc API kết nối ra bên ngoài giúp agent tra cứu dữ liệu, đọc file hoặc tác động vào hệ thống khác.
- **System prompt:** Các chỉ dẫn định hình vai trò, nhiệm vụ và những rule mà model phải tuân theo khi làm việc.
- **State và memory:** Nơi lưu trữ lịch sử trò chuyện, kết quả từ các lần gọi tool trước đó và trạng thái hiện tại xuyên suốt một session.
- **Guardrail và điều kiện dừng:** Các lớp bảo vệ kiểm soát đầu vào, đầu ra kèm giới hạn số vòng lặp để chặn agent chạy sai hoặc tốn chi phí không kiểm soát.

## 3. Phân biệt AI Agent, workflow và chatbot

Nhiều bạn mới làm quen hay gọi mọi app có gắn LLM là agent, nhưng thực tế không phải vậy. Trong [bài viết về cách xây dựng agent của Anthropic](https://www.anthropic.com/engineering/building-effective-agents), họ chỉ rõ workflow là hệ thống mà LLM và tool được điều phối qua những đường đi định sẵn trong code, còn agent là khi LLM tự điều khiển quá trình và cách dùng tool.

Hướng dẫn của OpenAI cũng ghi rõ chatbot đơn giản, lệnh gọi LLM một lần hay bộ phân loại cảm xúc không phải là agent vì model không hề nắm quyền điều khiển luồng công việc.

| Tiêu chí | Gọi LLM một lần (chatbot) | Workflow | AI Agent |
| --- | --- | --- | --- |
| Ai quyết định bước tiếp theo | Không có bước tiếp, trả lời xong là hết | Đường đi được lập trình sẵn trong code | Model tự quyết định dựa trên kết quả vừa nhận |
| Có gọi tool không | Không, hoặc chỉ nhận dữ liệu đính kèm sẵn | Có, nhưng gọi theo thứ tự cố định | Có, model tự chọn tool và thời điểm gọi |
| Chi phí và độ trễ | Thấp và phản hồi nhanh | Trung bình, dễ dự đoán trước | Cao hơn do gọi model lặp lại nhiều vòng |
| Khi nào nên dùng | Hỏi đáp, tóm tắt, dịch thuật, phân loại | Quy trình nghiệp vụ đã rõ từng bước | Bài toán mở, không đoán trước được số bước |

Anthropic khuyên nên bắt đầu bằng cách đơn giản nhất, vì nhiều app chỉ cần một lần gọi LLM kèm theo retrieval và vài ví dụ mẫu là đủ. Bạn chỉ nên dùng agent khi gặp bài toán mở, không thể đoán trước cần bao nhiêu bước xử lý.

Nhìn lại ví dụ bộ phân loại `sentiment_router` ở phiên bản cũ của bài viết này, đó chính xác là một workflow với đường đi viết cứng trong code chứ chưa phải agent. Bạn có thể đọc thêm bài [phân biệt agent và harness](https://200lab.io/blog/phan-biet-agent-va-harness) để nắm rõ hơn ranh giới thiết kế này.

## 4. Ví dụ AI Agent trong thực tế

Để dễ hình dung khi nào cần tới vòng lặp tự quyết của agent, chúng ta có thể nhìn vào ba nhóm bài toán phổ biến dưới đây:

- **Coding agent:** Agent tự đọc code, sửa nhiều file, chạy test kiểm tra rồi đọc log lỗi để sửa tiếp cho tới khi pass. Anthropic nêu đây là ví dụ agent hữu ích vì có bộ test tự động giúp kiểm tra kết quả rõ ràng.
- **Customer support:** Trợ lý trò chuyện trực tiếp với khách hàng kết hợp gọi tool để tra cứu đơn hàng, kiểm tra tồn kho hoặc xử lý hoàn tiền. Hiệu quả của loại agent này đo được qua việc yêu cầu của khách có được giải quyết xong hay không.
- **Research agent:** Agent tự chia nhỏ câu hỏi, tìm kiếm qua nhiều nguồn, đọc và tổng hợp lại thành báo cáo. Nhóm này thường kết hợp kỹ thuật [RAG (Retrieval-Augmented Generation)](https://200lab.io/blog/rag-la-gi) để lấy đúng tài liệu nội bộ của công ty.

## 5. Hướng dẫn tạo AI Agent với LangChain và LangGraph

Ở phần thực hành này, mình và các bạn sẽ làm một trợ lý chăm sóc khách hàng cho shop online với 2 tool: tra cứu đơn hàng và tính phí ship. Dữ liệu đơn hàng được mình để sẵn dạng dictionary giả lập trong code để bạn chép về chạy thử được ngay.

Bản cũ của bài viết từng dùng các đường dẫn import như `langchain.chat_models` hay `langchain.document_loaders`, nay đã không còn tồn tại trong bản 1.x nên mình viết mới lại từ đầu. Nếu chưa quen với framework này, bạn có thể xem trước bài giới thiệu [LangChain là gì](https://200lab.io/blog/langchain-la-gi).

### 5.1 Cài đặt thư viện

Máy của bạn cần cài sẵn Python từ bản 3.10 trở lên, sau đó chạy lệnh cài đặt các gói thư viện sau:

```bash
pip install -U langchain langgraph langchain-openai
```

Tiếp theo, bạn xuất API key ra biến môi trường trên máy tính:

```bash
export OPENAI_API_KEY="sk-..."
```

Dùng biến môi trường để API key nằm ngoài code, không ghi thẳng vào file như bản cũ của bài.

### 5.2 Tạo AI Agent đầu tiên với create_agent

Decorator `@tool` giúp biến một hàm Python bình thường thành tool cho agent, phần docstring là mô tả để model đọc và biết khi nào cần gọi hàm này. Mình để 2 tool trong file `agent_tools.py` để mục 5.3 dùng lại.

```python
# agent_tools.py
from langchain.tools import tool

ORDERS = {
    "DH1024": {"status": "đang giao", "province": "Đà Nẵng", "weight_kg": 2.5},
    "DH1025": {"status": "đã giao", "province": "Hà Nội", "weight_kg": 1.0},
}

@tool
def get_order(order_id: str) -> str:
    """Tra cứu trạng thái, tỉnh nhận và cân nặng của một đơn hàng theo mã đơn."""
    order = ORDERS.get(order_id.upper())
    if order is None:
        return f"Không tìm thấy đơn {order_id}"
    return str(order)

@tool
def shipping_fee(province: str, weight_kg: float) -> str:
    """Tính phí ship (VND) theo tỉnh nhận và cân nặng (kg)."""
    base = 20000 if province in ("Hà Nội", "TP.HCM") else 30000
    return f"{int(base + 5000 * weight_kg)} VND"
```

Hàm `create_agent` nhận vào tên model, danh sách tool cùng `system_prompt`, mình gắn thêm `ModelCallLimitMiddleware(run_limit=6)` làm điều kiện dừng để giới hạn tối đa 6 lần gọi model trong một lượt chạy.

```python
# agent_basic.py
from langchain.agents import create_agent
from langchain.agents.middleware import ModelCallLimitMiddleware

from agent_tools import get_order, shipping_fee

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[get_order, shipping_fee],
    system_prompt="Bạn là trợ lý chăm sóc khách hàng của một shop online. Trả lời ngắn gọn bằng tiếng Việt.",
    middleware=[ModelCallLimitMiddleware(run_limit=6)],
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Đơn DH1024 của mình tới đâu rồi, phí ship bao nhiêu?"}]}
)

for msg in result["messages"]:
    msg.pretty_print()
```

Dưới đây là kết quả in ra màn hình khi mình chạy thật trên máy với bộ thư viện `langchain` 1.4.7 và `langgraph` 1.2.19:

```text
================================ Human Message =================================

Đơn DH1024 của mình tới đâu rồi, phí ship bao nhiêu?
================================== Ai Message ==================================
Tool Calls:
  get_order (call_DELjINy9u0fwibXBmbTblLjb)
 Call ID: call_DELjINy9u0fwibXBmbTblLjb
  Args:
    order_id: DH1024
================================= Tool Message =================================
Name: get_order

{'status': 'đang giao', 'province': 'Đà Nẵng', 'weight_kg': 2.5}
================================== Ai Message ==================================
Tool Calls:
  shipping_fee (call_SzGVmg9RDoEoOYquiSBzGPW6)
 Call ID: call_SzGVmg9RDoEoOYquiSBzGPW6
  Args:
    province: Đà Nẵng
    weight_kg: 2.5
================================= Tool Message =================================
Name: shipping_fee

42500 VND
================================== Ai Message ==================================

Đơn DH1024 của bạn hiện **đang giao** đến **Đà Nẵng**.
Phí ship là **42.500đ**.
```

Nhìn vào kết quả, bạn sẽ thấy model tự biết gọi `get_order` trước để kiểm tra mã đơn. Khi thấy đơn hàng này giao đi Đà Nẵng và nặng 2,5 kg, nó mới tự động gọi tiếp hàm `shipping_fee` truyền đúng hai giá trị vừa lấy được vào, rồi mới tổng hợp câu trả lời cho khách.

Mình không hề viết dòng code nào ép thứ tự chạy trước sau này, và đó chính là điểm làm nên sự khác biệt so với workflow.

### 5.3 Tự dựng agent loop bằng LangGraph StateGraph

Hàm `create_agent` ở trên được xây trên LangGraph. Nếu muốn hiểu rõ cơ chế bên trong hoặc cần tùy biến sâu từng bước xử lý, chúng ta có thể tự dựng lại vòng lặp này bằng `StateGraph` giống bản cũ của bài, nhưng lần này có model thật.

Graph này gồm node `"model"`, node `"tools"` dùng class `ToolNode`, cạnh điều kiện `tools_condition` để rẽ nhánh sang chạy tool nếu model yêu cầu hoặc kết thúc nếu đã xong, kèm một cạnh nối từ `"tools"` quay ngược về `"model"`.

Tham số `recursion_limit` được truyền vào lúc chạy để chặn vòng lặp chạy mãi không dừng. Đoạn code bên dưới dùng lại 2 tool trong file `agent_tools.py` ở mục 5.2.

```python
# agent_graph.py
from langchain.chat_models import init_chat_model
from langchain.messages import SystemMessage
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition

from agent_tools import get_order, shipping_fee

tools = [get_order, shipping_fee]
model = init_chat_model("openai:gpt-5.5").bind_tools(tools)

SYSTEM = SystemMessage("Bạn là trợ lý chăm sóc khách hàng của một shop online. Trả lời ngắn gọn bằng tiếng Việt.")

def call_model(state: MessagesState):
    response = model.invoke([SYSTEM] + state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("model", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "model")
# Model muốn gọi tool thì sang node "tools", không thì kết thúc
builder.add_conditional_edges("model", tools_condition)
# Có kết quả tool thì quay lại model để quyết định bước tiếp
builder.add_edge("tools", "model")

graph = builder.compile()

result = graph.invoke(
    {"messages": [{"role": "user", "content": "Đơn DH1024 của mình tới đâu rồi, phí ship bao nhiêu?"}]},
    {"recursion_limit": 10},
)
print(result["messages"][-1].content)
```

Kết quả trả về khi thực thi đoạn graph trên:

```text
Đơn DH1024 của bạn hiện **đang giao** đến **Đà Nẵng**.
Phí ship là **42.500đ**.
```

Graph tự đi qua node model, node tools rồi quay lại model, và cho cùng câu trả lời như bản `create_agent` ở mục 5.2.

### 5.4 Khi nào cần multi-agent

Ở bài viết cũ, mình từng dựng ví dụ gồm 3 agent là Research, Strategy và Writer nối đuôi nhau viết email marketing. Nhìn kỹ lại thì 3 bước đó chạy theo thứ tự cố định từ đầu tới cuối, nên nó gần với một workflow hơn là multi-agent.

Chúng ta chỉ nên tách nhỏ công việc cho nhiều subagent khi một context window đơn lẻ không chứa nổi lượng thông tin, hoặc khi cần xử lý nhiều nhánh song song. Theo tài liệu LangChain, mỗi subagent sẽ chạy trong một context riêng biệt và agent chính chỉ đứng ở giữa làm nhiệm vụ điều phối.

## 6. Những lưu ý khi đưa AI Agent vào production

- **Điều kiện dừng:** Luôn đặt giới hạn số lần gọi model và số lần gọi tool bằng các bộ đếm như `ModelCallLimitMiddleware` hay `ToolCallLimitMiddleware`. Anthropic cũng khuyên có điều kiện dừng như số vòng lặp tối đa. Mình thử hạ `run_limit` xuống 1 thì agent dừng ngay sau lần tra đơn và trả về dòng `Model call limits exceeded: run limit (1/1)`.
- **Quyền của tool:** Mỗi tool chỉ nên được cấp quyền làm đúng phần việc cần thiết của nó. Với những tác vụ để lại hậu quả lớn như xóa dữ liệu, chuyển tiền hay gửi email hàng loạt, bạn cần chặn lại chờ người duyệt qua `HumanInTheLoopMiddleware`.
- **Tracing và eval:** Bạn cần ghi log lại toàn bộ từng bước trong vòng lặp để biết agent đã gọi tool gì, truyền tham số nào và sai ở đâu mà sửa, đồng thời chạy eval kiểm tra định kỳ. LangChain gợi ý dùng LangSmith để theo dõi phần tracing này.
- **Chi phí và độ trễ:** Do đặc thù phải gọi model lặp đi lặp lại qua nhiều vòng suy luận, chi phí token và thời gian chờ phản hồi của agent sẽ cao hơn một lần gọi LLM thông thường. Anthropic gọi đây là đánh đổi độ trễ và chi phí để lấy kết quả tốt hơn.
- **Mô tả tool rõ ràng:** Anthropic khuyên đầu tư vào mô tả và tài liệu của từng tool kỹ như khi viết prompt. Với LangChain, đó chính là tên hàm, tham số và docstring.

## 7. Kết luận

Về mặt kỹ thuật, AI Agent là một model gọi tool trong vòng lặp cho tới khi xong việc hoặc chạm điều kiện dừng. Khi bắt tay vào làm sản phẩm, bạn cứ bắt đầu từ cách tiếp cận đơn giản nhất: nếu luồng xử lý đã định hình rõ ràng từng bước thì dùng workflow, còn khi gặp bài toán mở không đoán trước được đường đi thì mới dựng agent.

Khi agent đã chạy được, phần khó tiếp theo là vận hành nó ổn định: lúc nào cần agent, cấp quyền, giữ state và dừng đúng lúc. Khóa học dưới đây đi sâu vào phần này.

![Agent Harness Foundations](https://assets.200lab.io/sha256/7d/7d10dab27b878eeb97b71bf30112001ee144303e521c32d1aa20dd5466b2f6d8/generations/3b7588991172f063d96597212486357a0e018d60bec854c770c2a5546b206488)

- [Agent Harness Foundations](https://200lab.io/courses/agent-harness-foundations.md)

## Đọc thêm

- [Self Evolution: cách để Grok Bot tự cải tiến liên tục từ kinh nghiệm làm việc và người dùng](https://200lab.io/blog/grok-bot-self-evolution.md): Self Evolution giúp Grok Bot rút bài học từ việc hằng ngày, nhưng bot chỉ học khi có ghi log kèm bằng chứng và thay đổi rủi ro vẫn chờ bạn duyệt.
- [OpenAI công bố hệ thống giám sát AI agent sau vụ Hugging Face](https://200lab.io/blog/openai-ai-agent-monitoring-system.md): Giám sát AI agent ở OpenAI có 4 lớp, dựng sau vụ agent thoát sandbox. Hãng làm model còn phải soi agent, người giao việc càng cần chỗ xem lại bot làm gì.
- [Cách đặt Grok Bot gửi bản tin cuối ngày nhắc việc cho chủ shop](https://200lab.io/blog/grok-bot-daily-digest-routine.md): Bản tin cuối ngày giúp người bán một mình gom việc còn treo. Với routine của Grok Bot, bot chỉ đọc bảng và nhắc việc theo lịch, chủ shop vẫn tự quyết định.
- [Dùng Grok Bot UI UX Pro Max làm landing page shop nến tiếng Việt](https://200lab.io/blog/ui-ux-pro-max-bot-candle-shop-landing-page.md): Grok Bot UI UX Pro Max dựng landing page shop nến; mình kiểm tra từng bước design system, contrast, font tiếng Việt và rút ra câu nhắn chỉnh bot cho mỗi bước.
- [Dùng AI trả lời đánh giá xấu đúng chính sách, không cam kết vượt mức](https://200lab.io/blog/reply-bad-reviews-with-ai.md): Trả lời đánh giá xấu dễ khiến shop cam kết vượt chính sách. Cách khắc phục: chép chính sách đổi trả vào skill, bot chỉ soạn nháp, chủ shop duyệt rồi mới đăng.
- [Mọi bài viết chủ đề AI](https://200lab.io/blog/tags/ai.md)

Toàn bộ nội dung: https://200lab.io/llms.txt