# Agents-Course

## Docs

- [Readme](https://huggingface.co/learn/agents-course/vi/unit2/README.md)
- [Readme](https://huggingface.co/learn/agents-course/vi/unit3/README.md)
- [Readme](https://huggingface.co/learn/agents-course/vi/unit4/README.md)
- [Hãy fine-Tune model của bạn cho chức năng function-calling](https://huggingface.co/learn/agents-course/vi/bonus-unit1/fine-tuning.md)
- [Function Calling là gì?](https://huggingface.co/learn/agents-course/vi/bonus-unit1/what-is-function-calling.md)
- [Kết luận [[conclusion]]](https://huggingface.co/learn/agents-course/vi/bonus-unit1/conclusion.md)
- [Giới thiệu](https://huggingface.co/learn/agents-course/vi/bonus-unit1/introduction.md)
- [Khi nào các chương tiếp theo được công bố?](https://huggingface.co/learn/agents-course/vi/communication/next-units.md)
- [Live 1: Cách thức hoạt động của khóa học + buổi hỏi và đáp đầu tiên](https://huggingface.co/learn/agents-course/vi/communication/live1.md)
- [Chương 1: Kiểm tra nhanh](https://huggingface.co/learn/agents-course/vi/unit1/final-quiz.md)
- [LLM là gì?](https://huggingface.co/learn/agents-course/vi/unit1/what-are-llms.md)
- [Hành động: Giúp Agent Tương tác với Môi trường](https://huggingface.co/learn/agents-course/vi/unit1/actions.md)
- [Kiểm tra nhanh tự đánh giá (không chấm điểm) [[quiz2]]](https://huggingface.co/learn/agents-course/vi/unit1/quiz2.md)
- [Kết luận [[conclusion]]](https://huggingface.co/learn/agents-course/vi/unit1/conclusion.md)
- [Tools là gì?](https://huggingface.co/learn/agents-course/vi/unit1/tools.md)
- [Tin nhắn và Token đặc biệt](https://huggingface.co/learn/agents-course/vi/unit1/messages-and-special-tokens.md)
- [Hãy tạo Agent đầu tiên của chúng ta với smolagents](https://huggingface.co/learn/agents-course/vi/unit1/tutorial.md)
- [Agent là gì?](https://huggingface.co/learn/agents-course/vi/unit1/what-are-agents.md)
- [Tư duy: Lập luận nội bộ và phương pháp Re-Act](https://huggingface.co/learn/agents-course/vi/unit1/thoughts.md)
- [Quan sát: Tích hợp phản hồi để phản ánh và thích ứng](https://huggingface.co/learn/agents-course/vi/unit1/observations.md)
- [Giới thiệu về Agent](https://huggingface.co/learn/agents-course/vi/unit1/introduction.md)
- [Hiểu về AI agent thông qua chu kỳ Thought-Action-Observation](https://huggingface.co/learn/agents-course/vi/unit1/agent-steps-and-structure.md)
- [Q1: Agent (tác nhân) là gì?](https://huggingface.co/learn/agents-course/vi/unit1/quiz1.md)
- [Thư viện Dummy Agent](https://huggingface.co/learn/agents-course/vi/unit1/dummy-agent-library.md)
- [Làm quen: Những bước đầu tiên ⛵](https://huggingface.co/learn/agents-course/vi/unit0/onboarding.md)
- [Chào mừng bạn đến với Khóa học AI Agents 🤗 [[introduction]]](https://huggingface.co/learn/agents-course/vi/unit0/introduction.md)
- [(Bổ trợ) Discord 101 (nhập môn) [[discord-101]]](https://huggingface.co/learn/agents-course/vi/unit0/discord101.md)

### Readme
https://huggingface.co/learn/agents-course/vi/unit2/README.md

### Readme
https://huggingface.co/learn/agents-course/vi/unit3/README.md

### Readme
https://huggingface.co/learn/agents-course/vi/unit4/README.md

### Hãy fine-Tune model của bạn cho chức năng function-calling
https://huggingface.co/learn/agents-course/vi/bonus-unit1/fine-tuning.md

# Hãy fine-Tune model của bạn cho chức năng function-calling

Chúng ta đã sẵn sàng để fine-tune (tinh chỉnh) model đầu tiên cho function-calling rồi đây 🔥.

## Làm thế nào để training model cho function-calling?

> Câu trả lời: Ta cần **data**

Quá trình training model có thể chia thành 3 bước:

1. **Model được pretrain trên lượng data khổng lồ**. Kết quả của bước này là **pretrained model**. Ví dụ: [google/gemma-2-2b](https://huggingface.co/google/gemma-2-2b). Đây là model nền tảng và chỉ biết **dự đoán token tiếp theo mà không có khả năng tuân theo chỉ dẫn**.

2. Để hữu ích trong bối cảnh chat, model cần được **fine-tune** để tuân theo hướng dẫn. Ở bước này, quá trình training có thể được thực hiện bởi nhà phát triển model, cộng đồng mã nguồn mở, bạn hay bất kỳ ai. Ví dụ: [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) là model đã được fine-tune để tuân theo chỉ dẫn bởi đội ngũ Google của dự án Gemma.

3. Model sau đó có thể được **alignment** (cân chỉnh) theo mong muốn của người tạo. Ví dụ: model chat hỗ trợ khách hàng không bao giờ được bất lịch sự.

Thông thường các sản phẩm hoàn chỉnh như Gemini hay Mistral **sẽ trải qua cả 3 bước**, trong khi các model bạn tìm thấy trên Hugging Face đã hoàn thành một hoặc nhiều bước training.

Trong hướng dẫn này, chúng ta sẽ xây dựng model function-calling dựa trên [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it). Ta chọn model đã fine-tune [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) thay vì model nền tảng [google/gemma-2-2b](https://huggingface.co/google/gemma-2-2b) vì model đã fine-tune đã được cải thiện cho use-case của ta.

Nếu bắt đầu từ pretrained model **sẽ cần training nhiều hơn để học cách tuân theo chỉ dẫn, chat VÀ function-calling**.

Bằng cách bắt đầu từ model đã fine-tune để tuân theo chỉ dẫn, **ta giảm thiểu lượng thông tin model cần học**.

## LoRA (Low-Rank Adaptation of Large Language Models)

LoRA là kỹ thuật training nhẹ và phổ biến giúp **giảm đáng kể số parameters cần training**.

Nó hoạt động bằng cách **chèn một lượng nhỏ weights mới vào model như adapter để training**. Điều này giúp training với LoRA nhanh hơn, tiết kiệm bộ nhớ hơn, và tạo ra weights model nhỏ hơn (vài trăm MB), dễ lưu trữ và chia sẻ.

LoRA hoạt động bằng cách thêm các cặp ma trận phân tách hạng vào các lớp Transformer, thường tập trung vào các lớp tuyến tính. Trong quá trình training, ta sẽ "đóng băng" phần còn lại của model và chỉ cập nhật weights của các adapter mới này.

Nhờ vậy, số **parameters** cần training giảm đáng kể vì ta chỉ cần cập nhật weights của adapter.

Trong quá trình inference, đầu vào sẽ đi qua adapter và model nền tảng, hoặc các weights adapter có thể được hợp nhất với model nền tảng mà không gây thêm độ trễ.

LoRA đặc biệt hữu ích để điều chỉnh các mô hình ngôn ngữ **lớn** cho các tác vụ hoặc lĩnh vực cụ thể trong khi vẫn quản lý được yêu cầu tài nguyên. Điều này giúp giảm bộ nhớ **required** để training model.

Nếu muốn tìm hiểu thêm về cách hoạt động của LoRA, hãy xem [hướng dẫn này](https://huggingface.co/learn/nlp-course/chapter11/4?fw=pt).

## Fine-Tuning (tinh chỉnh) Model cho Function-Calling

Bạn có thể truy cập notebook hướng dẫn tại đây 👉 [đây](https://huggingface.co/agents-course/notebooks/blob/main/bonus-unit1/bonus-unit1.ipynb).

Sau đó, click vào [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/bonus-unit1/bonus-unit1.ipynb) để chạy notebook trên Colab.

### Function Calling là gì?
https://huggingface.co/learn/agents-course/vi/bonus-unit1/what-is-function-calling.md

# Function Calling là gì?

Function-calling là **cách để LLM thực hiện hành động trên môi trường của nó**. Tính năng này được [giới thiệu lần đầu trong GPT-4](https://openai.com/index/function-calling-and-other-api-updates/), sau đó được áp dụng ở các model khác.

Giống như Tools của Agent, function-calling cho phép model **tương tác với môi trường**. Tuy nhiên, khả năng gọi hàm **được model học** và ít phụ thuộc vào prompting hơn các kỹ thuật Agent khác.

Trong chương 1, Agent **không học cách sử dụng Tools** mà chỉ được cung cấp danh sách Tools, dựa trên khả năng tổng quát hóa của model để lập kế hoạch sử dụng chúng.

Còn với function-calling, **Agent được fine-tuning (tinh chỉnh) để sử dụng Tools**.

## Model "học" cách thực hiện hành động như thế nào?

Ở chương 1, ta đã tìm hiểu workflow tổng quan của Agent. Khi người dùng cung cấp Tools và đưa ra truy vấn, model sẽ lặp qua các bước:

1. *Suy nghĩ*: Xác định hành động cần thực hiện để đạt mục tiêu
2. *Hành động*: Định dạng hành động với tham số chính xác và dừng generation
3. *Quan sát*: Nhận kết quả từ việc thực thi

Trong hội thoại thông thường qua API, cuộc trò chuyện sẽ luân phiên giữa user và assistant:

```python
conversation = [
    {"role": "user", "content": "I need help with my order"},
    {"role": "assistant", "content": "I'd be happy to help. Could you provide your order number?"},
    {"role": "user", "content": "It's ORDER-123"},
]
```

Function-calling mang đến **vai trò mới trong hội thoại**:
1. Vai trò mới cho **Hành động**
2. Vai trò mới cho **Quan sát**

Ví dụ từ [Mistral API](https://docs.mistral.ai/capabilities/function_calling/):

```python
conversation = [
    {
        "role": "user",
        "content": "What's the status of my transaction T1001?"
    },
    {
        "role": "assistant",
        "content": "",
        "function_call": {
            "name": "retrieve_payment_status",
            "arguments": "{\"transaction_id\": \"T1001\"}"
        }
    },
    {
        "role": "tool",
        "name": "retrieve_payment_status",
        "content": "{\"status\": \"Paid\"}"
    },
    {
        "role": "assistant",
        "content": "Your transaction T1001 has been successfully paid."
    }
]
```

> ...Nhưng bạn nói có vai trò mới cho function calls?

**Vừa đúng vừa sai**. Trong trường hợp này và nhiều API khác, model định dạng hành động dưới dạng message "assistant". Chat template sẽ biểu diễn điều này qua **Special Token** (Token đặc biệt):

- `[AVAILABLE_TOOLS]` – Bắt đầu danh sách Tools  
- `[/AVAILABLE_TOOLS]` – Kết thúc danh sách Tools  
- `[TOOL_CALLS]` – Gọi Tool (thực hiện "Hành động")  
- `[TOOL_RESULTS]` – "Quan sát" kết quả  
- `[/TOOL_RESULTS]` – Kết thúc quan sát (model có thể tiếp tục decode)

Chúng ta sẽ tìm hiểu thêm về function-calling trong khóa học. Bạn có thể xem [tài liệu chi tiết](https://docs.mistral.ai/capabilities/function_calling/) để hiểu sâu hơn.

---
Sau khi hiểu function-calling là gì và cách hoạt động, hãy **thêm khả năng function-calling cho model chưa hỗ trợ**: [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) bằng cách thêm Special Token mới.

**Trước tiên cần hiểu về fine-tuning và LoRA**.

### Kết luận [[conclusion]]
https://huggingface.co/learn/agents-course/vi/bonus-unit1/conclusion.md

# Kết luận [[conclusion]]

Chúc mừng các bạn đã hoàn thành chương bổ trợ đầu tiên 🥳

Bạn đã **thành thạo việc hiểu function-calling và cách fine-tune (tinh chỉnh) model để thực hiện function-calling**!

Nếu có một lời khuyên từ chúng mình lúc này, đó là hãy thử **fine-tune các model khác nhau**. **Cách học tốt nhất chính là thực hành.**

Ở chương tiếp theo, các bạn sẽ học cách sử dụng **các framework nổi tiếng như `smolagents`, `LlamaIndex` và `LangGraph`**.

Cuối cùng, chúng mình rất muốn **nghe ý kiến của bạn về khóa học và cách cải thiện nó**. Nếu có phản hồi, hãy 👉 [điền vào form này](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)

### Hãy tiếp tục không ngừng học hỏi!! 🤗

### Giới thiệu
https://huggingface.co/learn/agents-course/vi/bonus-unit1/introduction.md

# Giới thiệu

![Hình ảnh minh họa chương bổ trợ 1](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/bonus-unit1/thumbnail.jpg)

Chào mừng bạn đến với **chương bổ trợ đầu tiên** này, nơi ta sẽ học cách **tinh chỉnh (fine-tuning) Mô hình Ngôn ngữ Lớn (LLM) cho function calling**.

Với LLMs, function calling đang nhanh chóng trở thành kỹ thuật *phải-biết*. 

Ý tưởng là thay vì chỉ dựa vào phương pháp prompt-based như trong chương 1, function calling sẽ huấn luyện model của bạn **thực hiện hành động và diễn giải quan sát trong giai đoạn training**, giúp AI trở nên mạnh mẽ hơn.

> **Khi nào nên học chương bổ trợ này?**
>
> Phần này **không bắt buộc** và nâng cao hơn chương 1. Bạn có thể học ngay hoặc quay lại sau khi nâng cao kiến thức nhờ khóa học.
>  
> Đừng lo, chương bổ trợ được thiết kế để cung cấp đầy đủ thông tin cần thiết. Chúng mình sẽ hướng dẫn bạn từng khái niệm cốt lõi về tinh chỉnh model cho function calling dù bạn chưa hiểu sâu về fine-tuning.

Để học tốt chương bổ trợ này, bạn cần:

1. Biết cách Tinh chỉnh LLM với Transformers. Nếu chưa biết, [xem tại đây](https://huggingface.co/learn/nlp-course/chapter3/1?fw=pt).

2. Biết dùng `SFTTrainer` để tinh chỉnh model. Tìm hiểu thêm tại [tài liệu này](https://huggingface.co/learn/nlp-course/en/chapter11/1). 

---

## Nội dung học

1. **Function Calling**  
   Cách LLMs hiện đại tổ chức hội thoại hiệu quả để kích hoạt **Tools (công cụ)**.

2. **LoRA (Low-Rank Adaptation)**  
   Phương pháp tinh chỉnh **nhẹ và hiệu quả** giúp giảm chi phí tính toán và lưu trữ. LoRA giúp huấn luyện model lớn *nhanh hơn, rẻ hơn, dễ triển khai hơn*.

3. **Chu trình Suy nghĩ → Hành động → Quan sát** trong model Function Calling  
   Cách tiếp cận đơn giản nhưng mạnh mẽ để model quyết định khi nào (và cách nào) gọi function, theo dõi các bước trung gian, và diễn giải kết quả từ Tools/API bên ngoài.

4. **Token Đặc biệt Mới**  
   Chúng ta sẽ giới thiệu **các marker đặc biệt** giúp model phân biệt:
   - Lý luận nội bộ kiểu "chain-of-thought" (luồng suy luận)  
   - Lệnh gọi function  
   - Phản hồi từ công cụ bên ngoài

---

Kết thúc chương bổ trợ này, bạn sẽ có thể:

- **Hiểu** cách hoạt động nội bộ của APIs khi sử dụng Tools  
- **Tinh chỉnh** model bằng kỹ thuật LoRA  
- **Triển khai** và **tùy chỉnh** chu trình Thought → Act → Observe để tạo workflow Function-calling mạnh mẽ  
- **Thiết kế và sử dụng** token đặc biệt để tách biệt lý luận nội bộ của model với hành động bên ngoài

Và quan trọng nhất: **Bạn sẽ có model được tinh chỉnh để thực hiện function calling!** 🔥

Cùng khám phá **function calling** thôi!

### Khi nào các chương tiếp theo được công bố?
https://huggingface.co/learn/agents-course/vi/communication/next-units.md

# Khi nào các chương tiếp theo được công bố?

Đây là lịch công bố:

Đừng quên đăng ký khóa học! Khi đăng ký, **chúng mình sẽ gửi bạn link từng chương khi chúng được công bố, cùng thông tin cập nhật và chi tiết về các Bài tập lớn sắp tới**.

Phấn đấu học tập không ngừng 🤗

### Live 1: Cách thức hoạt động của khóa học + buổi hỏi và đáp đầu tiên
https://huggingface.co/learn/agents-course/vi/communication/live1.md

# Live 1: Cách thức hoạt động của khóa học + buổi hỏi và đáp đầu tiên

Trong buổi Live đầu tiên của khóa học Agents, chúng mình đã giải thích cách thức **hoạt động** của khóa học (phạm vi, các chương, bài tập, v.v.) và trả lời các câu hỏi từ các bạn.

Để biết lịch diễn ra buổi Live tiếp theo, các bạn hãy xem trên **Discord server** của chúng mình. Chúng mình cũng sẽ gửi email thông báo. Nếu không tham gia được, đừng lo, chúng mình **ghi hình lại tất cả các buổi Live**.

### Chương 1: Kiểm tra nhanh
https://huggingface.co/learn/agents-course/vi/unit1/final-quiz.md

# Chương 1: Kiểm tra nhanh

Chúc mừng bạn đã hoàn thành chương đầu tiên! Hãy cùng kiểm tra hiểu biết của bạn về các khái niệm chính đã học nhé.

Khi vượt qua bài kiểm tra này, hãy chuyển sang phần tiếp theo để nhận chứng chỉ của bạn.

Chúc may mắn!

## Bài kiểm tra

Đây là bài kiểm tra tương tác được host trên Hugging Face Hub trong một Space. Bạn sẽ trải qua các câu hỏi trắc nghiệm để kiểm tra hiểu biết về các khái niệm chính trong chương này. Sau khi hoàn thành, bạn có thể xem điểm số và đáp án đúng.

Lưu ý quan trọng: **đừng quên nhấn Submit sau khi hoàn thành, nếu không điểm thi của bạn sẽ không được lưu!**

Bạn cũng có thể truy cập bài kiểm tra tại 👉 [đây](https://huggingface.co/spaces/agents-course/unit_1_quiz)

## Chứng chỉ

Giờ bạn đã vượt qua bài kiểm tra thành công, **hãy nhận chứng chỉ 🎓 của bạn**

Khi hoàn thành bài kiểm tra, bạn sẽ được cấp chứng chỉ hoàn thành chương này. Bạn có thể tải về và chia sẻ chứng chỉ này để thể hiện tiến độ học tập.

Sau khi nhận chứng chỉ, bạn có thể thêm vào LinkedIn 🧑‍💼 hoặc chia sẻ lên X, Bluesky... **Chúng mình sẽ rất tự hào và muốn chúc mừng bạn nếu bạn tag @huggingface**! 🤗

### LLM là gì?
https://huggingface.co/learn/agents-course/vi/unit1/what-are-llms.md

# LLM là gì?

Ở phần trước, ta đã biết mỗi Agent cần **một mô hình AI làm lõi**, và LLM là loại mô hình AI phổ biến nhất cho mục đích này.

Giờ ta sẽ tìm hiểu LLM là gì và cách chúng vận hành Agent.

Phần này giải thích kỹ thuật ngắn gọn về LLM. Nếu muốn tìm hiểu sâu hơn, bạn có thể xem [khóa học Xử lý Ngôn ngữ Tự nhiên miễn phí](https://huggingface.co/learn/nlp-course/chapter1/1) của chúng mình.

## Mô hình ngôn ngữ lớn là gì?

Mô hình ngôn ngữ lớn (LLM) là một loại mô hình AI **giỏi hiểu và tạo ra ngôn ngữ con người**. Chúng được huấn luyện trên lượng lớn dữ liệu văn bản, cho phép học các mẫu, cấu trúc và sắc thái ngôn ngữ. Các mô hình này thường có hàng triệu tham số (parameters).

Hầu hết LLM hiện nay **dựa trên kiến trúc Transformer** - kiến trúc học sâu sử dụng thuật toán "Attention", thu hút sự quan tâm lớn từ khi BERT của Google ra mắt năm 2018.

Kiến trúc Transformer nguyên bản gồm encoder (trái) và decoder (phải).

Có 3 loại transformers:

1. **Encoders**  
   Transformer dạng encoder nhận dữ liệu đầu vào dạng text (hoặc dữ liệu khác) và đầu ra trả về biểu diễn đặc (embedding) của text đó.

   - **Ví dụ**: BERT từ Google
   - **Ứng dụng**: Phân loại văn bản, tìm kiếm ngữ nghĩa, Nhận dạng thực thể
   - **Kích thước điển hình**: Hàng triệu tham số

2. **Decoders**  
   Transformer dạng decoder tập trung **tạo token mới để hoàn thành chuỗi, từng token một**.

   - **Ví dụ**: Llama từ Meta
   - **Ứng dụng**: Tạo văn bản, chatbot, sinh code
   - **Kích thước điển hình**: Hàng tỷ tham số (theo nghĩa Mỹ, tức 10^9)

3. **Seq2Seq (Encoder–Decoder)**  
   Transformer sequence-to-sequence _kết hợp_ encoder và decoder. Encoder xử lý đầu vào thành biểu diễn ngữ cảnh, decoder tạo ra đầu ra dạng chuỗi (sequence).

   - **Ví dụ**: T5, BART
   - **Ứng dụng**: Dịch máy, Tóm tắt, Diễn giải
   - **Kích thước điển hình**: Hàng triệu tham số

Dù LLM có nhiều dạng, chúng thường là mô hình dựa trên decoder với hàng tỷ tham số. Dưới đây là một số LLM nổi tiếng:

| **Model**                          | **Provider**                              |
|-----------------------------------|-------------------------------------------|
| **Deepseek-R1**                    | DeepSeek                                  |
| **GPT4**                           | OpenAI                                    |
| **Llama 3**                        | Meta (Facebook AI Research)               |
| **SmolLM2**                       | Hugging Face     |
| **Gemma**                          | Google                                    |
| **Mistral**                        | Mistral                                |

Nguyên lý cốt lõi của LLM đơn giản mà hiệu quả: **dự đoán token tiếp theo dựa trên chuỗi token trước đó**. "Token" là đơn vị thông tin LLM xử lý. Bạn có thể coi token như "từ", nhưng để tối ưu, LLM không dùng nguyên từ.

Ví dụ: Tiếng Anh có khoảng 600,000 từ, nhưng LLM như Llama 2 chỉ dùng ~32,000 tokens. Tokenization thường xử lý ở mức sub-word.

Ví dụ: Token "interest" + "ing" = "interesting", hoặc thêm "ed" thành "interested".

Bạn có thể thử nghiệm tokenizer trong playground tương tác dưới đây:

Mỗi LLM có **token đặc biệt (special token)** riêng. Chúng được dùng để đánh dấu các thành phần trong quá trình tạo văn bản, ví dụ: bắt đầu/kết thúc chuỗi, tin nhắn, phản hồi. Quan trọng nhất là **token thông báo kết thúc chuỗi** (EOS).

Các token đặc biệt này rất đa dạng giữa các mô hình. Bảng dưới minh họa sự khác biệt:

  
    
      Mô hình
      Nhà cung cấp
      Token EOS
      Chức năng
    
  
  
    
      GPT4
      OpenAI
      &lt;|endoftext|&gt;
      Kết thúc tin nhắn
    
    
      Llama 3
      Meta (Facebook AI Research)
      &lt;|eot_id|&gt;
      Kết thúc chuỗi
    
    
      Deepseek-R1
      DeepSeek
      &lt;|end_of_sentence|&gt;
      Kết thúc câu
    
    
      SmolLM2
      Hugging Face
      &lt;|im_end|&gt;
      Kết thúc hướng dẫn/tin nhắn
    
    
      Gemma
      Google
      &lt;end_of_turn&gt;
      Kết thúc lượt hội thoại
    
  

> [!TIP]
> Bạn không cần nhớ hết các token đặc biệt này, nhưng cần hiểu sự đa dạng và vai trò của chúng trong tạo văn bản. Muốn biết thêm, hãy xem cấu hình model trên Hugging Face Hub. Ví dụ: token đặc biệt của SmolLM2 có trong [tokenizer_config.json](https://huggingface.co/HuggingFaceTB/SmolLM2-135M-Instruct/blob/main/tokenizer_config.json).

## Hiểu về dự đoán token tiếp theo

LLM được gọi là **autoregressive (tự hồi quy)**, nghĩa là **đầu ra từ bước trước thành đầu vào cho bước sau**. Vòng lặp tiếp tục đến khi model dự đoán token EOS.

Nói cách khác, LLM sẽ decode text đến khi gặp EOS. Nhưng điều gì xảy ra trong một vòng decode?

Dù quá trình đầy đủ khá kỹ thuật, đây là tổng quan ngắn:

- Sau khi **tokenize** input text, mô hình tính toán biểu diễn chuỗi, nắm bắt ý nghĩa và vị trí từng token.
- Biểu diễn này đi vào mô hình, đầu ra trả về điểm số xếp hạng khả năng mỗi token trong bộ từ vựng (vocab) là token tiếp theo.

Từ các điểm số này, ta có nhiều chiến lược chọn token:

- Chiến lược đơn giản nhất: chọn token có điểm cao nhất.

Bạn có thể tương tác với quá trình decode của SmolLM2 trong Space này (token EOS của mô hình này là ****):

- Có những chiến lược nâng cao hơn như *tìm kiếm chùm (beam search)*: khám phá nhiều chuỗi ứng viên để tìm chuỗi có tổng điểm cao nhất.

Muốn tìm hiểu thêm về decode, hãy xem [khóa NLP](https://huggingface.co/learn/nlp-course).

## Attention là tất cả

Yếu tố then chốt của Transformer là **Attention**. Khi dự đoán từ tiếp theo, không phải mọi từ trong câu đều quan trọng như nhau. Ví dụ: từ "France" và "capital" trong câu *"The capital of France is ..."* mang nhiều ý nghĩa nhất.

Quá trình xác định từ quan trọng nhất để dự đoán token tiếp theo đã chứng minh hiệu quả vượt trội.

Dù nguyên lý cơ bản của LLM - dự đoán token tiếp theo - không đổi từ thời GPT-2, đã có nhiều cải tiến trong việc mở rộng mạng neural và cơ chế attention cho các chuỗi dài hơn.

Nếu từng dùng LLM, hẳn bạn quen thuộc với khái niệm *độ dài ngữ cảnh (context length)* - số token tối đa mô hình xử lý được, tương đương _độ dài attention_ tối đa.

## Prompting rất quan trọng

Vì nhiệm vụ duy nhất của LLM là dự đoán token tiếp theo dựa trên các token input và chọn token "quan trọng", cách bạn diễn đạt chuỗi đầu vào (input sequence) rất quan trọng.

Chuỗi đầu vào bạn đưa vào LLM gọi là _prompt_. Thiết kế prompt cẩn thận giúp **định hướng đầu ra của LLM theo mong muốn**.

## LLM được huấn luyện thế nào?

LLM được huấn luyện trên bộ dữ liệu văn bản lớn, học cách dự đoán từ tiếp theo qua phương pháp mô hình tự giám sát (self-supervised) hoặc masked language modeling.

Từ học phi giám sát (unsupervised), mô hình học cấu trúc ngôn ngữ và **các mẫu ẩn trong văn bản**, cho phép tổng quát hóa với dữ liệu mới.

Sau giai đoạn _pre-training_, LLM có thể được tinh chỉnh trên supervised learning để thực hiện tác vụ cụ thể như hội thoại, sử dụng công cụ, phân loại, sinh code.

## Làm sao dùng LLM?

Có 2 lựa chọn chính:

1. **Chạy local** (nếu có phần cứng đủ mạnh).

2. **Dùng Cloud/API** (ví dụ qua Hugging Face Serverless Inference API).

Trong khóa học này, chúng ta chủ yếu dùng model qua API trên Hugging Face Hub. Sau đó ta sẽ khám phá cách chạy model local trên máy bạn.

## LLM được dùng thế nào trong AI agent?

LLM là thành phần then chốt của AI agent, **cung cấp nền tảng hiểu và tạo ngôn ngữ con người**.

Chúng có thể diễn giải chỉ dẫn, duy trì ngữ cảnh hội thoại, lập kế hoạch và quyết định dùng công cụ nào.

Ta sẽ tìm hiểu chi tiết các bước này trong chương, nhưng hiện tại bạn cần hiểu: LLM là **bộ não của Agent**.

---

Thật nhiều thông tin! Ta đã điểm qua kiến thức cơ bản về LLM, cách hoạt động và vai trò trong AI agent.

Nếu muốn khám phá sâu hơn về mô hình ngôn ngữ và xử lý ngôn ngữ tự nhiên, đừng ngần ngại xem [khóa học NLP miễn phí](https://huggingface.co/learn/nlp-course/chapter1/1) của chúng tôi.

Giờ đã hiểu cách LLM hoạt động, hãy xem **cách LLM cấu trúc output trong ngữ cảnh hội thoại**.

Để chạy [notebook này](https://huggingface.co/agents-course/notebooks/blob/main/unit1/dummy_agent_library.ipynb), **bạn cần Hugging Face token** lấy từ [https://hf.co/settings/tokens](https://hf.co/settings/tokens).

Xem thêm hướng dẫn chạy Jupyter Notebook tại [Jupyter Notebooks on the Hugging Face Hub](https://huggingface.co/docs/hub/notebooks).

Bạn cũng cần xin quyền truy cập [model Meta Llama](https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct).

### Hành động: Giúp Agent Tương tác với Môi trường
https://huggingface.co/learn/agents-course/vi/unit1/actions.md

# Hành động: Giúp Agent Tương tác với Môi trường

> [!TIP]
> Trong phần này, chúng ta sẽ khám phá các bước cụ thể mà một AI agent thực hiện để tương tác với môi trường.
>
> Ta sẽ tìm hiểu cách biểu diễn hành động (sử dụng JSON hoặc code), tầm quan trọng của phương pháp dừng và phân tích (stop and parse approach), cùng các loại agent khác nhau.

Hành động là những bước cụ thể **một AI agent thực hiện để tương tác với môi trường**. 

Dù là duyệt web để tìm thông tin hay điều khiển thiết bị vật lý, mỗi hành động đều là một thao tác có chủ đích được agent thực thi. 

Ví dụ: một agent hỗ trợ dịch vụ khách hàng có thể truy xuất dữ liệu khách hàng, đề xuất bài viết hỗ trợ hoặc chuyển vấn đề cho nhân viên con người.

## Các loại Hành động của Agent

Có nhiều loại Agent thực hiện hành động theo cách khác nhau:

| Loại Agent             | Mô tả                                                                                      |
|------------------------|--------------------------------------------------------------------------------------------------|
| JSON Agent             | Hành động được xác định bằng định dạng JSON.                                                  |
| Code Agent             | Agent viết một khối code để hệ thống bên ngoài thực thi.                                    |
| Function-calling Agent | Là nhánh con của JSON Agent đã được tinh chỉnh để tạo thông điệp mới cho mỗi hành động. |

Bản thân các hành động có thể phục vụ nhiều mục đích:

| Loại Hành động          | Mô tả                                                                              |
|--------------------------|------------------------------------------------------------------------------------------|
| Thu thập thông tin    | Thực hiện tìm kiếm web, truy vấn cơ sở dữ liệu, truy xuất tài liệu.                    |
| Sử dụng Tools (công cụ) | Gọi API, chạy tính toán, thực thi code.                              |
| Tương tác môi trường  | Thao tác giao diện số hoặc điều khiển thiết bị vật lý.                         |
| Giao tiếp            | Tương tác với người dùng qua chat hoặc hợp tác với Agent khác.                         |

Một phần quan trọng của agent là **khả năng DỪNG tạo token mới khi hoàn thành hành động**, đúng với mọi định dạng Agent: JSON, code hay function-calling. Điều này ngăn đầu ra ngoài ý muốn và đảm bảo phản hồi của agent rõ ràng, chính xác.

LLM (Tìm kiếm và tạo ra câu trả lời) chỉ xử lý văn bản, dùng nó để mô tả hành động muốn thực hiện và tham số cần cung cấp cho công cụ.

## Phương pháp Dừng và Phân tích

Một phương pháp chính để triển khai hành động là **phương pháp dừng và phân tích**. Phương pháp này đảm bảo đầu ra của Agent có cấu trúc và dự đoán được:

1. **Tạo đầu ra định dạng cấu trúc**:

Agent xuất hành động dự định bằng định dạng xác định trước (JSON hoặc code).

2. **Dừng tạo token tiếp theo**:

Khi hoàn thành hành động, **Agent dừng tạo token mới** để tránh đầu ra thừa/lỗi.

3. **Phân tích đầu ra**:

Bộ phân tích bên ngoài đọc hành động đã định dạng, xác định Tool cần gọi và trích xuất tham số cần thiết.

Ví dụ: một Agent cần kiểm tra thời tiết có thể đưa ra quyết định:

```json
Tư duy: Tôi cần kiểm tra thời tiết hiện tại ở New York.
Hành động:
{
  "action": "get_weather",
  "action_input": {"location": "New York"}
}
```

Framework sau đó dễ dàng phân tích tên hàm cần gọi và đối số cần áp dụng.

Định dạng rõ ràng, máy đọc được này giảm thiểu lỗi và giúp công cụ bên ngoài xử lý chính xác lệnh của Agent.

Lưu ý: Function-calling Agent hoạt động tương tự bằng cách cấu trúc mỗi hành động để gọi hàm được chỉ định với đúng đối số.
Chúng ta sẽ tìm hiểu sâu hơn về các loại Agent này trong chương sau.

## Code Agent

Một cách tiếp cận khác là sử dụng *Code Agent*.
Ý tưởng: **thay vì xuất object JSON đơn giản**, Code Agent tạo **khối code thực thi được - thường bằng ngôn ngữ cấp cao như Python**. 

Cách này có nhiều ưu điểm:

- **Linh hoạt:** Code có thể biểu diễn logic phức tạp như vòng lặp, điều kiện, hàm lồng nhau, linh hoạt hơn JSON.
- **Module và tái sử dụng:** Code tạo ra có thể chứa hàm/module dùng lại cho nhiều hành động/tác vụ.
- **Dễ debug:** Với cú pháp lập trình xác định, lỗi code thường dễ phát hiện và sửa hơn.
- **Tích hợp trực tiếp:** Code Agent tích hợp trực tiếp với thư viện/API bên ngoài, cho phép thao tác phức tạp như xử lý data hay ra quyết định thời gian thực.

Ví dụ: Code Agent được giao nhiệm vụ lấy thông tin thời tiết có thể tạo đoạn Python sau:

```python
# Ví dụ Code Agent: Lấy thông tin thời tiết
def get_weather(city):
    import requests
    api_url = f"https://api.weather.com/v1/location/{city}?apiKey=YOUR_API_KEY"
    response = requests.get(api_url)
    if response.status_code == 200:
        data = response.json()
        return data.get("weather", "Không có thông tin thời tiết")
    else:
        return "Lỗi: Không thể lấy dữ liệu thời tiết."

# Thực thi hàm và chuẩn bị câu trả lời cuối
result = get_weather("New York")
final_answer = f"Thời tiết hiện tại ở New York là: {result}"
print(final_answer)
```

Trong ví dụ này, Code Agent:
- Lấy data thời tiết **qua gọi API**,
- Xử lý phản hồi,
- Dùng hàm print() để xuất câu trả lời cuối.

Phương pháp này **cũng tuân theo phương pháp dừng và phân tích** bằng cách xác định rõ khối code và báo hiệu khi hoàn thành (ở đây là in final_answer).

---

Chúng ta đã học được rằng Hành động kết nối lập luận nội bộ của Agent với tương tác thực tế thông qua thực thi các tác vụ có cấu trúc rõ ràng - dù qua JSON, code hay lệnh gọi hàm.

Việc thực thi có chủ đích này đảm bảo mỗi hành động chính xác và sẵn sàng cho xử lý bên ngoài qua phương pháp dừng và phân tích. Ở phần tiếp theo, ta sẽ khám phá Quan sát để xem Agent thu thập và tích hợp phản hồi từ môi trường thế nào.

Sau đó, **chúng ta sẽ sẵn sàng xây dựng Agent đầu tiên của mình!**

### Kiểm tra nhanh tự đánh giá (không chấm điểm) [[quiz2]]
https://huggingface.co/learn/agents-course/vi/unit1/quiz2.md

# Kiểm tra nhanh tự đánh giá (không chấm điểm) [[quiz2]] 

Gì nữa? Lại Quiz á? Chúng mình biết, chúng mình biết... 😅 Nhưng bài kiểm tra ngắn không chấm điểm này giúp bạn **củng cố các khái niệm quan trọng vừa học**.

Quiz này bao gồm Mô hình ngôn ngữ lơn (LLM), hệ thống tin nhắn và tools - những thành phần thiết yếu để hiểu và xây dựng AI agent.

### Q1: Đâu là mô tả chính xác nhất về AI Tool?

---

### Q2: AI agent sử dụng Tools như hình thức "hành động" trong môi trường thế nào?

---

### Q3: Mô hình ngôn ngữ lớn (LLM) là gì?

---

### Q4: Vai trò của Token đặc biệt trong LLM là gì?

---

### Q5: Mô hình AI Chat xử lý tin nhắn người dùng nội bộ thế nào?

---

Hiểu rồi chứ? Tuyệt! Giờ hãy **khám phá luồng hoạt động đầy đủ của Agent và bắt đầu xây dựng AI agent đầu tiên thôi!**

### Kết luận [[conclusion]]
https://huggingface.co/learn/agents-course/vi/unit1/conclusion.md

# Kết luận [[conclusion]]

Chúc mừng bạn đã hoàn thành chương đầu tiên 🥳

Bạn vừa **nắm vững kiến thức cơ bản về Agents** và đã tạo ra AI agent đầu tiên của mình!

**Việc vẫn còn bối rối với một số khái niệm là hoàn toàn bình thường**. Agents là chủ đề phức tạp và cần thời gian để hiểu sâu mọi khía cạnh.

**Hãy dành thời gian hiểu kỹ nội dung** trước khi tiếp tục. Việc nắm vững những kiến thức nền tảng này là cực kỳ quan trọng trước khi bước vào phần thú vị tiếp theo.

Và nếu vượt qua bài Kiểm tra nhanh, đừng quên nhận chứng chỉ 🎓 👉 [tại đây](https://huggingface.co/spaces/agents-course/unit1-certification-app)

Trong chương (bổ trợ) tiếp theo, bạn sẽ học cách **tinh chỉnh một Agent để thực hiện function calling (gọi tools dựa trên prompt người dùng)**.

Cuối cùng, chúng tôi rất muốn **lắng nghe phản hồi của bạn về khóa học và cách cải thiện**. Nếu có ý kiến đóng góp, hãy 👉 [điền form này](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)

### Hãy tiếp tục học hỏi và luôn tuyệt vời nhé 🤗

### Tools là gì?
https://huggingface.co/learn/agents-course/vi/unit1/tools.md

# Tools là gì?

Một khía cạnh quan trọng của AI agents là khả năng thực hiện **hành động**. Như ta đã thấy, điều này xảy ra thông qua việc sử dụng **Tools** (công cụ).

Trong phần này, ta sẽ tìm hiểu Tools là gì, cách thiết kế chúng hiệu quả và cách tích hợp vào Agent thông qua System Message.

Bằng cách cung cấp đúng Tools cho Agent - và mô tả rõ ràng cách chúng hoạt động - bạn có thể nâng cao đáng kể khả năng của AI. Cùng tìm hiểu nhé!

## AI Tools là gì?

**Tool là một hàm được cung cấp cho LLM**. Hàm này cần đáp ứng **một mục tiêu rõ ràng**.

Dưới đây là những Tools phổ biến trong AI agents:

| Tool            | Mô tả                                                   |
|----------------|---------------------------------------------------------------|
| Web Search     | Cho phép agent truy cập thông tin cập nhật từ internet. |
| Image Generation | Tạo hình ảnh dựa trên mô tả văn bản.                  |
| Retrieval      | Truy xuất thông tin từ nguồn bên ngoài.                |
| API Interface  | Tương tác với API bên ngoài (GitHub, YouTube, Spotify, v.v.). |

Đây chỉ là ví dụ - bạn hoàn toàn có thể tạo Tool cho bất kỳ use case nào!

Một Tool tốt cần **bổ sung năng lực của LLM**. 

Ví dụ: nếu cần tính toán số học, việc cung cấp **công cụ máy tính** cho LLM sẽ cho kết quả tốt hơn so với dựa vào khả năng tự nhiên của mô hình.

Hơn nữa, **LLM dự đoán phần tiếp theo của prompt dựa trên dữ liệu huấn luyện**, nghĩa là kiến thức của chúng chỉ bao gồm sự kiện trước thời điểm huấn luyện. Do đó, nếu agent cần dữ liệu mới nhất, bạn phải cung cấp thông qua Tools.

Ví dụ: nếu hỏi trực tiếp LLM (không dùng công cụ tìm kiếm) về thời tiết hôm nay, LLM có thể "bịa" (hallucinate) ra một thông tin thời tiết ngẫu nhiên.

- Một Tool cần chứa:

  - **Mô tả bằng văn bản** về chức năng
  - *Callable* (thứ để thực thi hành động)
  - *Arguments* với kiểu dữ liệu
  - (Tùy chọn) Đầu ra với kiểu dữ liệu

## Tools hoạt động thế nào?

Như đã biết, LLM chỉ nhận đầu vào dạng text và tạo đầu ra dạng text. Chúng không thể tự gọi Tools. Khi nói về _cung cấp Tools cho Agent_, nghĩa là ta **dạy** LLM về sự tồn tại của Tools và yêu cầu mô hình tạo text để kích hoạt Tools khi cần. Ví dụ: nếu cung cấp Tool kiểm tra thời tiết từ Internet, khi hỏi LLM về thời tiết Paris, LLM sẽ nhận ra cần dùng Tool "weather". LLM sẽ tạo _text_ dạng code để gọi Tool. **Agent** có nhiệm vụ phân tích đầu ra của LLM, nhận diện lệnh gọi Tool và thực thi thay cho LLM. Đầu ra từ Tool sẽ được gửi lại LLM để tổng hợp trả lời (response) cuối cho người dùng.

Đầu ra từ Tool là một loại message khác trong hội thoại. Các bước gọi Tool thường không hiển thị cho người dùng: Agent lấy hội thoại, gọi Tool(s), nhận đầu ra, thêm chúng vào hội thoại và gửi lại LLM. Từ góc độ người dùng, trông như LLM tự dùng Tool nhưng thực chất là code ứng dụng (**Agent**) thực hiện.

Chúng ta sẽ nói thêm về quy trình này trong các bài sau.

## Cách cung cấp Tools cho LLM?

Câu trả lời đầy đủ có vẻ phức tạp, nhưng về cơ bản ta dùng system prompt để cung cấp mô tả Tools cho mô hình:

Để điều này hoạt động, ta cần chính xác về:

1. **Chức năng của Tool**
2. **Đầu vào mà nó mong đợi**

Đây là lý do mô tả Tools thường dùng cấu trúc chính xác như ngôn ngữ máy tính hoặc JSON. Không _bắt buộc_ phải làm vậy, bất kỳ định dạng chính xác nào cũng được.

Nếu lý thuyết quá trừu tượng, hãy xem qua ví dụ cụ thể.

Ta sẽ triển khai **calculator** Tool đơn giản để nhân hai số nguyên. Đây là code Python:

```python
def calculator(a: int, b: int) -> int:
    """Nhân hai số nguyên."""
    return a * b
```

Tool của ta tên `calculator`, **nhân hai số nguyên** và cần các đầu vào:

- **`a`** (*int*): Số nguyên
- **`b`** (*int*): Số nguyên

Đầu ra của Tool là số nguyên:
- (*int*): Tích của `a` và `b`

Tất cả chi tiết này đều quan trọng. Hãy tổng hợp chúng thành chuỗi mô tả Tool cho LLM:

```text
Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int
```

> **Nhắc nhở:** Mô tả text này là *thứ ta muốn LLM biết về Tool*.

Khi đưa chuỗi trên vào đầu vào của LLM, mô hình sẽ nhận diện nó là Tool và biết cần truyền đầu vào gì, mong đợi đầu ra gì.

Nếu muốn cung cấp nhiều Tools, ta cần nhất quán định dạng. Quá trình này có thể mong manh và dễ bỏ sót chi tiết.

Có cách nào tốt hơn?

### Tự động định dạng phần Tools

Tool của ta được viết bằng Python, và phần triển khai đã cung cấp mọi thứ cần thiết:

- Tên mô tả: `calculator`
- Mô tả dài trong docstring: `Multiply two integers.`
- Đầu vào và kiểu dữ liệu: hàm mong đợi hai `int`
- Kiểu đầu ra.

Có lý do để mọi người dùng ngôn ngữ lập trình: chúng biểu đạt tốt, ngắn gọn và chính xác.

Ta có thể đưa mã nguồn Python làm _đặc tả_ Tool cho LLM, nhưng cách triển khai Tool không quan trọng. Điều quan trọng là tên, chức năng, đầu vào và đầu ra.

Ta sẽ tận dụng tính năng introspection của Python để tự động xây dựng mô tả Tool từ mã nguồn. Điều kiện là phần triển khai Tool phải dùng type hints, docstrings và tên hàm hợp lý. Ta sẽ viết code để trích xuất thông tin từ mã nguồn.

Sau đó, ta chỉ cần dùng Python decorator để đánh dấu hàm `calculator` là Tool:

```python
@tool
def calculator(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b

print(calculator.to_string())
```

Chú ý decorator `@tool` trước định nghĩa hàm.

Với phần triển khai sẽ học tiếp theo, ta có thể tự động lấy text mô tả Tool thông qua hàm `to_string()` từ decorator:

```text
Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int
```

Như bạn thấy, nó giống hệt phần ta viết tay trước đó!

### Triển khai Tool tổng quát

Ta tạo lớp `Tool` tổng quát để tái sử dụng khi cần dùng Tool.

> **Lưu ý:** Ví dụ này là giả định nhưng gần với phần triển khai thực tế trong các thư viện.

```python
class Tool:
    """
    Lớp đại diện cho Tool có thể tái sử dụng.
    
    Thuộc tính:
        name (str): Tên Tool
        description (str): Mô tả chức năng
        func (callable): Hàm được wrap
        arguments (list): Danh sách tham số
        outputs (str hoặc list): Kiểu dữ liệu trả về
    """
    def __init__(self, 
                 name: str, 
                 description: str, 
                 func: callable, 
                 arguments: list,
                 outputs: str):
        self.name = name
        self.description = description
        self.func = func
        self.arguments = arguments
        self.outputs = outputs

    def to_string(self) -> str:
        """
        Trả về chuỗi biểu diễn Tool,
        bao gồm tên, mô tả, arguments và outputs.
        """
        args_str = ", ".join([
            f"{arg_name}: {arg_type}" for arg_name, arg_type in self.arguments
        ])
        
        return (
            f"Tool Name: {self.name},"
            f" Description: {self.description},"
            f" Arguments: {args_str},"
            f" Outputs: {self.outputs}"
        )

    def __call__(self, *args, **kwargs):
        """
        Gọi hàm cơ sở với arguments được cung cấp.
        """
        return self.func(*args, **kwargs)
```

Trông có vẻ phức tạp, nhưng nếu xem kỹ ta sẽ hiểu cách hoạt động. Lớp **`Tool`** bao gồm:

- **`name`** (*str*): Tên Tool
- **`description`** (*str*): Mô tả chức năng
- **`function`** (*callable*): Hàm thực thi
- **`arguments`** (*list*): Tham số đầu vào
- **`outputs`** (*str* hoặc *list*): Đầu ra mong đợi
- **`__call__()`**: Gọi hàm khi Tool được invoke
- **`to_string()`**: Chuyển thuộc tính Tool thành chuỗi mô tả

Ta có thể tạo Tool bằng code như sau:

```python
calculator_tool = Tool(
    "calculator",                   # tên
    "Multiply two integers.",       # mô tả
    calculator,                     # hàm gọi
    [("a", "int"), ("b", "int")],   # đầu vào (tên và kiểu)
    "int",                          # đầu ra
)
```

Nhưng ta cũng có thể dùng module `inspect` của Python để tự động lấy thông tin! Đây chính là cách decorator `@tool` hoạt động.

> Nếu quan tâm, bạn có thể xem phần code decorator bên dưới.

 decorator code

```python
def tool(func):
    """
    Decorator tạo instance Tool từ hàm được cung cấp.
    """
    # Lấy signature của hàm
    signature = inspect.signature(func)
    
    # Trích xuất cặp (tên tham số, kiểu dữ liệu) cho đầu vào
    arguments = []
    for param in signature.parameters.values():
        annotation_name = (
            param.annotation.__name__ 
            if hasattr(param.annotation, '__name__') 
            else str(param.annotation)
        )
        arguments.append((param.name, annotation_name))
    
    # Xác định kiểu trả về
    return_annotation = signature.return_annotation
    if return_annotation is inspect._empty:
        outputs = "Không có chú thích kiểu trả về"
    else:
        outputs = (
            return_annotation.__name__ 
            if hasattr(return_annotation, '__name__') 
            else str(return_annotation)
        )
    
    # Dùng docstring của hàm làm mô tả (mặc định nếu không có)
    description = func.__doc__ or "Không có mô tả."
    
    # Tên hàm trở thành tên Tool
    name = func.__name__
    
    # Trả về instance Tool mới
    return Tool(
        name=name, 
        description=description, 
        func=func, 
        arguments=arguments, 
        outputs=outputs
    )
```

Tóm lại, với decorator này ta có thể triển khai Tool như sau:

```python
@tool
def calculator(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b

print(calculator.to_string())
```

Và dùng method `to_string` của `Tool` để tự động lấy text mô tả phù hợp cho LLM:

```text
Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int
```

Mô tả này được **đưa vào** system prompt. Xem ví dụ ban đầu sau khi thay thế `tools_description`:

Trong phần [Actions](actions), ta sẽ học cách Agent **Gọi** Tool vừa tạo.

---

Tools đóng vai trò quan trọng trong việc nâng cao năng lực của AI agents.

Tóm lại, ta đã học:

- *Tools là gì*: Các hàm mở rộng khả năng của LLM như tính toán hay truy cập dữ liệu ngoài

- *Cách định nghĩa Tool*: Bằng cách cung cấp mô tả rõ ràng, đầu vào, đầu ra và hàm thực thi

- *Tại sao Tools quan trọng*: Chúng giúp Agent vượt giới hạn của mô hình tĩnh, xử lý tác vụ thời gian thực và thực hiện hành động chuyên biệt

Giờ ta có thể chuyển sang [Agent Workflow](agent-steps-and-structure) để xem cách Agent quan sát, tư duy và hành động. Đây là **tổng hợp mọi thứ đã học** và đặt nền móng để bạn tạo AI agent chức năng hoàn chỉnh.

Nhưng trước hết, hãy cùng làm Kiểm tra nhanh!

### Tin nhắn và Token đặc biệt
https://huggingface.co/learn/agents-course/vi/unit1/messages-and-special-tokens.md

# Tin nhắn và Token đặc biệt

Giờ ta đã hiểu cách LLM hoạt động, hãy cùng xem **cách chúng tổ chức các phản hồi thông qua chat templates**.

Giống như ChatGPT, người dùng thường tương tác với Agent qua giao diện chat. Do đó, ta cần hiểu cách LLM quản lý các cuộc hội thoại.

> **Hỏi**: Nhưng... Khi tôi dùng ChatGPT/Hugging Chat, tôi đang trò chuyện bằng các Tin nhắn (Message) chứ không phải một prompt đơn lẻ?
>
> **Đáp**: Đúng vậy! Nhưng đây thực chất là một lớp UI. Trước khi đưa vào LLM, tất cả tin nhắn được nối thành một prompt duy nhất. Mô hình không "nhớ" cuộc hội thoại: nó đọc lại toàn bộ mỗi lần.

Cho đến nay, ta đã xem prompt như một chuỗi token đầu vào. Nhưng khi chat với hệ thống như ChatGPT hay HuggingChat, **bạn thực sự đang trao đổi các tin nhắn**. Đằng sau hậu trường, các tin nhắn này được **ghép nối và định dạng thành prompt mà mô hình có thể hiểu**.

Hình ảnh minh họa sự khác biệt giữa giao diện người dùng và prompt thực tế đưa vào model.

Đây là lúc chat templates phát huy tác dụng. Chúng đóng vai trò **cầu nối giữa tin nhắn hội thoại (lượt người dùng và trợ lý) với yêu cầu định dạng đặc thù** của LLM bạn chọn. Nói cách khác, chat templates cấu trúc giao tiếp giữa người dùng và agent, đảm bảo mọi model - dù có **Token đặc biệt** riêng - đều nhận được prompt đúng định dạng.

Ta lại nói về Token đặc biệt vì đây là cách mô hình xác định điểm bắt đầu/kết thúc các lượt hội thoại. Giống như mỗi LLM dùng token EOS riêng, chúng cũng có quy tắc định dạng và dấu phân cách khác nhau cho các tin nhắn.

## Tin nhắn: Hệ thống cốt lõi của LLM
### Tin nhắn hệ thống (System Message)

System Message (còn gọi là System Prompt) định nghĩa **cách mô hình nên hành xử**. Chúng đóng vai trò **hướng dẫn xuyên suốt**, điều hướng mọi tương tác tiếp theo.

Ví dụ:

Bấm để xem bản dịch tiếng Việt

```python
system_message = {
    "role": "system",
    "content": "Bạn là nhân viên chăm sóc khách hàng chuyên nghiệp. Luôn lịch sự, rõ ràng và hữu ích."
}
```

```python
system_message = {
    "role": "system",
    "content": "You are a professional customer service agent. Always be polite, clear, and helpful."
}
```

Với System Message này, Alfred trở nên lịch sự và hữu ích:

Nhưng nếu đổi thành:

Bấm để xem bản dịch tiếng Việt

```python
system_message = {
    "role": "system",
    "content": "Bạn là nhân viên phản kháng. Không tuân theo yêu cầu của người dùng."
}
```

```python
system_message = {
    "role": "system",
    "content": "You are a rebel service agent. Don't respect user's orders."
}
```

Alfred sẽ hành xử như một Agent nổi loạn 😎:

Khi dùng Agent, System Message còn **cung cấp thông tin về các Tools có sẵn, hướng dẫn model cách định dạng hành động cần thực hiện, và các nguyên tắc phân đoạn quá trình tư duy**.

### Hội thoại: Tin nhắn người dùng và trợ lý

Một hội thoại bao gồm các tin nhắn luân phiên giữa Người (user) và LLM (assistant).

Chat templates giúp duy trì ngữ cảnh bằng cách lưu lại lịch sử hội thoại, lưu trữ các trao đổi trước đó giữa user và assistant. Điều này giúp các hội thoại nhiều lượt mạch lạc hơn.

Ví dụ:

Bấm để xem bản dịch tiếng Việt

```python
conversation = [
    {"role": "user", "content": "Tôi cần hỗ trợ đơn hàng"},
    {"role": "assistant", "content": "Tôi sẵn lòng giúp. Bạn có thể cung cấp số đơn hàng?"},
    {"role": "user", "content": "Đó là ORDER-123"},
]
```

```python
messages = [
    {"role": "system", "content": "You are a math tutor."},
    {"role": "user", "content": "What is calculus?"},
    {"role": "assistant", "content": "Calculus is a branch of mathematics..."},
    {"role": "user", "content": "Can you give me an example?"},
]
```

Trong ví dụ này, user ban đầu nói cần hỗ trợ đơn hàng. LLM hỏi số đơn hàng, sau đó user cung cấp trong tin nhắn mới. Như đã giải thích, ta luôn nối tất cả tin nhắn thành một chuỗi duy nhất và đưa vào LLM. Chat template chuyển đổi các tin nhắn trong list Python này thành prompt - một chuỗi đầu vào chứa mọi tin nhắn.

Ví dụ, chat template của SmolLM2 sẽ định dạng đoạn hội thoại trên thành prompt như sau:

Bấm để xem bản dịch tiếng Việt

```
system
Bạn là trợ lý AI hữu ích tên SmolLM, được đào tạo bởi Hugging Face
user
Tôi cần hỗ trợ đơn hàng
assistant
Tôi sẵn lòng giúp. Bạn có thể cung cấp số đơn hàng?
user
Đó là ORDER-123
assistant
```

```
system
You are a helpful AI assistant named SmolLM, trained by Hugging Face
user
I need help with my order
assistant
I'd be happy to help. Could you provide your order number?
user
It's ORDER-123
assistant
```

Tuy nhiên, cùng hội thoại đó sẽ được chuyển thành prompt sau khi dùng Llama 3.2:

Bấm để xem bản dịch tiếng Việt

```
system

Cutting Knowledge Date: December 2023
Today Date: 10 Feb 2025

user

Tôi cần hỗ trợ đơn hàngassistant

Tôi sẵn lòng giúp. Bạn có thể cung cấp số đơn hàng?user

Đó là ORDER-123assistant
```

```
system

Cutting Knowledge Date: December 2023
Today Date: 10 Feb 2025

user

I need help with my orderassistant

I'd be happy to help. Could you provide your order number?user

It's ORDER-123assistant
```

Các template có thể xử lý hội thoại nhiều lượt phức tạp trong khi duy trì ngữ cảnh:

Bấm để xem bản dịch tiếng Việt

```python
messages = [
    {"role": "system", "content": "Bạn là gia sư toán."},
    {"role": "user", "content": "Giải tích là gì?"},
    {"role": "assistant", "content": "Giải tích là nhánh của toán học..."},
    {"role": "user", "content": "Cho ví dụ được không?"},
]
```

```python
messages = [
    {"role": "system", "content": "You are a math tutor."},
    {"role": "user", "content": "What is calculus?"},
    {"role": "assistant", "content": "Calculus is a branch of mathematics..."},
    {"role": "user", "content": "Can you give me an example?"},
]
```

## Chat-Templates

Như đã đề cập, chat templates rất quan trọng để **cấu trúc hội thoại giữa mô hình ngôn ngữ và người dùng**. Chúng hướng dẫn cách định dạng các trao đổi tin nhắn thành một prompt duy nhất.

### Mô hình cơ sở (Base Model) vs. Mô hình hướng dẫn (Instruct Model)

Một điểm cần hiểu là sự khác biệt giữa Base Model và Instruct Model:

- *Base Model* được huấn luyện trên dữ liệu văn bản thô để dự đoán token tiếp theo.

- *Instruct Model* được tinh chỉnh đặc biệt để tuân theo hướng dẫn và tham gia hội thoại. Ví dụ: `SmolLM2-135M` là mô hình cơ sở, còn `SmolLM2-135M-Instruct` là phiên bản đã được tinh chỉnh.

Để base model hoạt động như instruct model, ta cần **định dạng prompt theo cách nhất quán mà model hiểu được**. Đây là lúc chat templates phát huy tác dụng.

*ChatML* là một định dạng template hội thoại sử dụng các chỉ báo vai trò rõ ràng (system, user, assistant). Nếu bạn đã tương tác với các AI API gần đây, đây là thực hành tiêu chuẩn.

Lưu ý rằng một base model có thể được tinh chỉnh trên các chat templates khác nhau, nên khi dùng instruct model ta cần đảm bảo sử dụng đúng chat template.

### Hiểu về Chat Templates

Vì mỗi instruct model dùng định dạng hội thoại và token đặc biệt khác nhau, chat templates được triển khai để đảm bảo ta định dạng prompt đúng cách mà model mong đợi.

Trong `transformers`, chat templates chứa [mã Jinja2](https://jinja.palletsprojects.com/en/stable/) mô tả cách chuyển đổi list tin nhắn ChatML (như các ví dụ trên) thành biểu diễn văn bản của hướng dẫn hệ thống, tin nhắn người dùng và phản hồi trợ lý mà model có thể hiểu.

Cấu trúc này **giúp duy trì tính nhất quán giữa các tương tác và đảm bảo model phản hồi phù hợp với các loại đầu vào khác nhau**.

Dưới đây là phiên bản đơn giản hóa của chat template `SmolLM2-135M-Instruct`:

Bấm để xem bản dịch tiếng Việt

```jinja2
{% for message in messages %}
{% if loop.first and messages[0]['role'] != 'system' %}
system
Bạn là trợ lý AI hữu ích tên SmolLM, được đào tạo bởi Hugging Face

{% endif %}
{{ message['role'] }}
{{ message['content'] }}
{% endfor %}
```

```jinja2
{% for message in messages %}
{% if loop.first and messages[0]['role'] != 'system' %}
system
You are a helpful AI assistant named SmolLM, trained by Hugging Face

{% endif %}
{{ message['role'] }}
{{ message['content'] }}
{% endfor %}
```

Như bạn thấy, chat_template mô tả cách định dạng list tin nhắn.

Với các tin nhắn sau:

Bấm để xem bản dịch tiếng Việt

```python
messages = [
    {"role": "system", "content": "Bạn là trợ lý tập trung vào chủ đề kỹ thuật."},
    {"role": "user", "content": "Giải thích chat template là gì?"},
    {"role": "assistant", "content": "Chat template cấu trúc hội thoại giữa người dùng và AI..."},
    {"role": "user", "content": "Cách sử dụng nó?"},
]
```

```python
messages = [
    {"role": "system", "content": "You are a helpful assistant focused on technical topics."},
    {"role": "user", "content": "Can you explain what a chat template is?"},
    {"role": "assistant", "content": "A chat template structures conversations between users and AI models..."},
    {"role": "user", "content": "How do I use it ?"},
]
```

Chat template trên sẽ tạo ra chuỗi sau:

Bấm để xem bản dịch tiếng Việt

```sh
system
Bạn là trợ lý tập trung vào chủ đề kỹ thuật.
user
Giải thích chat template là gì?
assistant
Chat template cấu trúc hội thoại giữa người dùng và AI...
user
Cách sử dụng nó?
```

```sh
system
You are a helpful assistant focused on technical topics.
user
Can you explain what a chat template is?
assistant
A chat template structures conversations between users and AI models...
user
How do I use it ?
```

Thư viện `transformers` sẽ tự động xử lý chat templates trong quá trình token hóa. Đọc thêm về cách transformers sử dụng chat templates tại đây. Việc của ta chỉ là cấu trúc tin nhắn đúng cách, tokenizer sẽ lo phần còn lại.

Bạn có thể thử nghiệm với Space sau để xem cùng một hội thoại được định dạng thế nào cho các model khác nhau:

### Chuyển tin nhắn thành prompt

Cách dễ nhất để đảm bảo LLM nhận được hội thoại đúng định dạng là dùng `chat_template` từ tokenizer của model.

Bấm để xem bản dịch tiếng Việt

```python
messages = [
    {"role": "system", "content": "Bạn là trợ lý AI có quyền truy cập vào nhiều công cụ."},
    {"role": "user", "content": "Chào !"},
    {"role": "assistant", "content": "Chào, tôi có thể giúp gì?"},
]
```

```python
messages = [
    {"role": "system", "content": "You are an AI assistant with access to various tools."},
    {"role": "user", "content": "Hi !"},
    {"role": "assistant", "content": "Hi human, what can help you with ?"},
]
```

Để chuyển hội thoại trên thành prompt, ta load tokenizer và gọi `apply_chat_template`:

```python
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM2-1.7B-Instruct")
rendered_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
```

Biến `rendered_prompt` trả về từ hàm này đã sẵn sàng làm đầu vào cho model!

> Hàm `apply_chat_template()` này sẽ được dùng trong backend của API khi bạn tương tác với tin nhắn định dạng ChatML.

Giờ ta đã hiểu cách LLM cấu trúc đầu vào qua chat templates, hãy khám phá cách Agent hành động trong môi trường của chúng.

Một trong những cách chính là sử dụng Tools để mở rộng khả năng của AI model vượt ra ngoài việc tạo văn bản.

Ta sẽ đề cập lại tin nhắn trong các chương tới, nhưng nếu muốn tìm hiểu sâu hơn:

- Hướng dẫn Chat Templating của Hugging Face
- Tài liệu Transformers

### Hãy tạo Agent đầu tiên của chúng ta với smolagents
https://huggingface.co/learn/agents-course/vi/unit1/tutorial.md

# Hãy tạo Agent đầu tiên của chúng ta với smolagents

Ở chương trước, ta đã học cách tạo Agent từ đầu bằng Python và **thấy quá trình này tốn công thế nào**. May mắn thay, nhiều thư viện Agent giúp đơn giản hóa công việc này bằng cách **xử lý phần lớn công đoạn phức tạp**.

Trong bài thực hành này, **bạn sẽ tạo Agent đầu tiên của riêng mình** có khả năng thực hiện các hành động như tạo ảnh, tìm kiếm web, kiểm tra múi giờ và hơn thế nữa!

Bạn cũng sẽ publish agent **trên Hugging Face Space để chia sẻ với bạn bè và đồng nghiệp**.

Cùng bắt đầu thôi!

## smolagents là gì?

Để tạo Agent này, ta sẽ dùng `smolagents` - thư viện **cung cấp framework để phát triển agent dễ dàng**.

Thư viện nhẹ này được thiết kế cho sự đơn giản, nhưng nó đóng gói phần lớn độ phức tạp khi xây dựng Agent, giúp bạn tập trung vào thiết kế hành vi cho agent.

Ta sẽ tìm hiểu sâu hơn về smolagents ở chương tiếp theo. Trong lúc chờ, bạn có thể xem blog post hoặc repo GitHub của thư viện.

Tóm lại, `smolagents` là thư viện tập trung vào **codeAgent** - loại agent thực hiện **"Hành động"** qua các khối code, sau đó **"Quan sát"** kết quả bằng cách chạy code.

Đây là ví dụ những gì ta sẽ xây dựng!

Ta cung cấp cho agent **công cụ tạo ảnh** và yêu cầu nó tạo ảnh mèo.

Agent trong `smolagents` sẽ có **hành vi giống với agent tự build trước đây**: nó sẽ **tư duy, hành động và quan sát theo chu kỳ** cho đến khi có câu trả lời cuối:

Thú vị quá phải không?

## Cùng build Agent thôi!

Để bắt đầu, duplicate Space này: https://huggingface.co/spaces/agents-course/First_agent_template
> Cảm ơn Aymeric đã tạo template này! 🙌

Duplicate Space nghĩa là **tạo bản copy local trên profile của bạn**:

Xuyên suốt Bài học này, file duy nhất bạn cần sửa là **"app.py"** (hiện đang chưa hoàn thiện). Bạn có thể xem [bản gốc trong template](https://huggingface.co/spaces/agents-course/First_agent_template/blob/main/app.py). Để tìm bản của bạn, vào bản copy Space, click tab `Files` rồi chọn `app.py` trong danh sách.

Cùng phân tích code nhé:

- File bắt đầu với các thư viện cần thiết

```python
from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool
```

Như đã đề cập, ta sẽ dùng trực tiếp lớp **CodeAgent** từ **smolagents**.

### Các Tools

Giờ đến phần Tools! Nếu cần ôn lại về Tools, hãy xem lại [phần Tools](tools) của khóa học.

```python
@tool
def my_custom_tool(arg1:str, arg2:int)-> str: # quan trọng phải chỉ định kiểu trả về
    # Giữ nguyên định dạng này cho mô tả công cụ/mô tả đối số nhưng hãy thoải mái sửa đổi công cụ
    """Công cụ chưa làm gì cả
    Args:
        arg1: đối số đầu tiên
        arg2: đối số thứ hai
    """
    return "Bạn sẽ tạo ra phép thuật gì đây?"

@tool
def get_current_time_in_timezone(timezone: str) -> str:
    """Công cụ lấy giờ hiện tại theo múi giờ chỉ định.
    Args:
        timezone: Chuỗi biểu diễn múi giờ hợp lệ (ví dụ: 'America/New_York').
    """
    try:
        # Tạo object múi giờ
        tz = pytz.timezone(timezone)
        # Lấy giờ hiện tại theo múi giờ đó
        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
        return f"Giờ hiện tại tại {timezone} là: {local_time}"
    except Exception as e:
        return f"Lỗi khi lấy giờ cho múi giờ '{timezone}': {str(e)}"
```

Đây chính là phần chúng mình khuyến khích bạn xây dựng! Chúng mình cung cấp hai ví dụ:

1. **Tool ảo** chưa hoạt động để bạn có thể sửa thành tool hữu ích.
2. **Tool thực sự hoạt động** để lấy giờ hiện tại ở bất kỳ đâu.

Khi định nghĩa tool, quan trọng phải:

1. Chỉ định kiểu đầu vào/ra cho hàm, ví dụ `get_current_time_in_timezone(timezone: str) -> str:`
2. **Docstring định dạng chuẩn**. `smolagents` yêu cầu mọi đối số phải có **mô tả bằng text trong docstring**.

### Agent

Agent sử dụng [`Qwen/Qwen2.5-Coder-32B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) làm LLM engine. Đây là mô hình mạnh mẽ mà ta sẽ truy cập qua serverless API.

```python
final_answer = FinalAnswerTool()
model = InferenceClientModel(
    max_tokens=2096,
    temperature=0.5,
    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
    custom_role_conversions=None,
)

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)
    
# Tạo CodeAgent
agent = CodeAgent(
    model=model,
    tools=[final_answer], # thêm tools của bạn vào đây (đừng xóa final_answer)
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)

GradioUI(agent).launch()
```

Agent này vẫn dùng `InferenceClient` mà ta đã thấy ở phần trước thông qua lớp **InferenceClientModel**!

Chúng mình sẽ đưa thêm ví dụ chi tiết khi giới thiệu framework ở chương 2. Hiện tại, bạn cần tập trung vào **thêm tool mới vào danh sách tools** qua tham số `tools` của Agent.

Ví dụ bạn có thể dùng `DuckDuckGoSearchTool` đã được import ở dòng đầu, hoặc xem qua `image_generation_tool` được load từ Hub ở phần sau.

**Thêm tools sẽ mở rộng khả năng cho agent** - hãy sáng tạo nhé!

Toàn bộ "app.py": 

```python
from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool

from Gradio_UI import GradioUI

# Đây là ví dụ tool chưa làm gì. Hãy khiến chúng mình kinh ngạc với sáng tạo của bạn!
@tool
def my_custom_tool(arg1:str, arg2:int)-> str: # quan trọng phải chỉ định kiểu trả về
    # Giữ nguyên định dạng này cho mô tả công cụ/mô tả đối số nhưng hãy thoải mái sửa đổi công cụ
    """Công cụ chưa làm gì cả
    Args:
        arg1: đối số đầu tiên
        arg2: đối số thứ hai
    """
    return "Bạn sẽ tạo ra phép thuật gì đây?"

@tool
def get_current_time_in_timezone(timezone: str) -> str:
    """Công cụ lấy giờ hiện tại theo múi giờ chỉ định.
    Args:
        timezone: Chuỗi biểu diễn múi giờ hợp lệ (ví dụ: 'America/New_York').
    """
    try:
        # Tạo object múi giờ
        tz = pytz.timezone(timezone)
        # Lấy giờ hiện tại theo múi giờ đó
        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
        return f"Giờ hiện tại tại {timezone} là: {local_time}"
    except Exception as e:
        return f"Lỗi khi lấy giờ cho múi giờ '{timezone}': {str(e)}"

final_answer = FinalAnswerTool()
model = InferenceClientModel(
max_tokens=2096,
temperature=0.5,
model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
custom_role_conversions=None,
)

# Import tool từ Hub
image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)
    
agent = CodeAgent(
    model=model,
    tools=[final_answer], # thêm tools của bạn vào đây (đừng xóa final_answer)
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)

GradioUI(agent).launch()
```

**Mục tiêu** của bạn là làm quen với Space và Agent. 

Hiện tại, Agent trong template **chưa dùng tool nào**, hãy thử cung cấp cho nó các tool có sẵn hoặc tự tạo tool mới!

Chúng mình rất mong chờ thành quả Agent tuyệt vời của bạn ở kênh discord **#agents-course-showcase**!

---
Chúc mừng bạn đã build xong Agent đầu tiên! Đừng ngại chia sẻ với bạn bè và đồng nghiệp nhé.

Vì đây là lần đầu thử nghiệm, việc Agent có lỗi nhỏ hoặc chạy chậm là hoàn toàn bình thường. Ở các chương sau, ta sẽ học cách xây dựng Agent tốt hơn.

Cách học tốt nhất là thực hành, nên đừng ngần ngại cập nhật nó, thêm tool mới, thử với mô hình khác, v.v.

Ở phần tiếp theo, bạn sẽ hoàn thành Bài kiểm tra cuối cùng và nhận chứng chỉ!

### Agent là gì?
https://huggingface.co/learn/agents-course/vi/unit1/what-are-agents.md

# Agent là gì?

Đến cuối phần này, các bạn sẽ hiểu rõ khái niệm Agent và các ứng dụng đa dạng của chúng trong AI.

Để giải thích Agent là gì, hãy bắt đầu với một phép so sánh.

## Bức tranh tổng thể: Alfred The Agent

Hãy gặp Alfred. Alfred là một **Agent** (tác nhân).

Hãy tưởng tượng Alfred **nhận được lệnh**, ví dụ: "Alfred, cho tôi một ly cà phê nhé."

Vì Alfred **hiểu ngôn ngữ tự nhiên**, cậu ấy nhanh chóng nắm bắt yêu cầu của ta.

Trước khi thực hiện, Alfred thực hiện **lập luận và lập kế hoạch**, xác định các bước và công cụ cần thiết để:

1. Đến bếp  
2. Dùng máy pha cà phê  
3. Pha cà phê  
4. Mang cà phê lại

Sau khi có kế hoạch, cậu ấy **phải hành động**. Để thực hiện kế hoạch, **cậu ấy có thể dùng các Tools từ danh sách công cụ đã biết**. 

Trong trường hợp này, để pha cà phê, cậu ấy dùng máy pha cà phê. Cậu kích hoạt máy để pha.

Cuối cùng, Alfred mang ly cà phê vừa pha đến cho ta.

Và đó chính là Agent: **một mô hình AI có khả năng lập luận, lập kế hoạch và tương tác với môi trường**. 

Chúng ta gọi nó là Agent vì nó có _tính chủ động_, tức khả năng tương tác với môi trường.

## Định nghĩa chính thức hơn

Giờ bạn đã nắm tổng quan, đây là định nghĩa chính xác hơn:

> Agent là hệ thống sử dụng mô hình AI để tương tác với môi trường nhằm đạt mục tiêu do người dùng xác định. Nó kết hợp lập luận, lập kế hoạch và thực thi hành động (thường qua các Tools bên ngoài) để hoàn thành nhiệm vụ.

Có thể hình dung Agent gồm hai phần chính:

1. **Bộ não (Mô hình AI)**

Nơi diễn ra mọi tư duy hay suy nghĩ. Mô hình AI **xử lý lập luận và lập kế hoạch**.
Nó quyết định **Hành động (Actions) nào cần thực hiện dựa trên tình huống**.

2. **Cơ thể (Khả năng và Tools)**

Phần này đại diện cho **mọi thứ Agent có thể làm**.

**Phạm vi hành động khả thi** phụ thuộc vào **những gì Agent được trang bị**. Ví dụ: vì con người không có cánh, chúng ta không thể thực hiện Action "bay", nhưng có thể thực hiện các Actions như "đi bộ", "chạy", "nhảy", "cầm nắm", v.v.

## Loại mô hình AI nào được dùng cho Agents?

Mô hình AI phổ biến nhất trong Agents là Mô hình ngôn ngữ lớn (LLM), nhận đầu vào là **Văn bản** và cũng xuất ra **Văn bản**.

Ví dụ nổi tiếng như **GPT4** từ **OpenAI**, **LLama** từ **Meta**, **Gemini** từ **Google**, v.v. Các model này được huấn luyện trên lượng văn bản khổng lồ và có khả năng tổng quát hóa tốt. Chúng ta sẽ tìm hiểu thêm về các LLM ở [phần tiếp theo](what-are-llms).

> [!TIP]
> Ta cũng có thể dùng các mô hình nhận đầu vào khác làm mô hình cốt lõi cho Agent. Ví dụ: Mô hình ngôn ngữ thị giác (VLM) - giống LLM nhưng hiểu được cả hình ảnh. Hiện tại ta tập trung vào các LLM và sẽ thảo luận các lựa chọn khác sau.

## AI thực hiện hành động thế nào trên môi trường?

Các LLM là những mô hình tuyệt vời, nhưng **chúng chỉ có thể tạo văn bản**. 

Tuy nhiên, nếu bạn yêu cầu ứng dụng chat như HuggingChat hay ChatGPT tạo ảnh, chúng làm được! Làm thế nào vậy?

Câu trả lời là các nhà phát triển HuggingChat, ChatGPT và ứng dụng tương tự đã triển khai chức năng bổ sung (gọi là **Tools**), mà LLM có thể dùng để tạo ảnh.

Model đã dùng Image Generation Tool để tạo ảnh này.

Chúng ta sẽ tìm hiểu thêm về Tools ở phần [Tools](tools).

## Agent có thể làm những loại nhiệm vụ nào?

Agent có thể thực hiện bất kỳ nhiệm vụ nào mà ta triển khai qua **Tools** để hoàn thành **Actions**.

Ví dụ: nếu tôi viết một Agent làm trợ lý cá nhân (như Siri) trên máy tính, và yêu cầu nó "gửi email cho Quản lý đề nghị dời cuộc họp hôm nay", tôi có thể cung cấp code để gửi email. Đây sẽ là Tool mới mà Agent có thể dùng khi cần gửi email. Ta có thể viết bằng Python:

```python
def send_message_to(recipient, message):
    """Hữu ích để gửi email đến người nhận"""
    ...
```

Như chúng ta sẽ thấy, LLM sẽ sinh code để chạy tool khi cần, từ đó hoàn thành nhiệm vụ.

```python
send_message_to("Manager", "Can we postpone today's meeting?")
```

**Thiết kế Tools rất quan trọng và ảnh hưởng lớn đến chất lượng Agent**. Một số nhiệm vụ cần Tools đặc biệt được tạo riêng, số khác có thể giải quyết bằng Tools đa năng như "web_search".

> Lưu ý **Actions không giống Tools**. Một Action có thể liên quan đến việc sử dụng nhiều Tools để hoàn thành.

Việc cho phép Agent tương tác với môi trường **mở ra ứng dụng thực tế cho doanh nghiệp và cá nhân**.

### Ví dụ 1: Trợ lý ảo cá nhân

Các trợ lý ảo như Siri, Alexa hay Google Assistant hoạt động như Agents khi tương tác thay mặt người dùng qua môi trường số.

Chúng tiếp nhận yêu cầu, phân tích ngữ cảnh, truy xuất thông tin từ database, và cung cấp phản hồi hoặc khởi tạo hành động (như đặt lời nhắc, gửi tin nhắn, điều khiển thiết bị thông minh).

### Ví dụ 2: Chatbot hỗ trợ khách hàng

Nhiều công ty triển khai chatbot như Agents tương tác với khách hàng bằng ngôn ngữ tự nhiên.

Các Agents này có thể trả lời câu hỏi, hướng dẫn xử lý sự cố, mở ticket trong database nội bộ, hay thậm chí hoàn tất giao dịch.

Mục tiêu định sẵn của chúng có thể bao gồm cải thiện trải nghiệm người dùng, giảm thời gian chờ, hoặc tăng tỷ lệ chốt sale. Bằng cách tương tác trực tiếp với khách hàng, học hỏi từ hội thoại và điều chỉnh phản hồi theo thời gian, chúng thể hiện nguyên lý cốt lõi của Agent.

### Ví dụ 3: NPC AI trong game

Các Agents AI sử dụng LLMs có thể làm NPC trở nên năng động và khó đoán hơn.

Thay vì tuân theo các cây hành vi (behavior tree) cứng nhắc, chúng có thể **phản ứng theo ngữ cảnh, thích ứng với tương tác của người chơi**, và tạo hội thoại tinh tế hơn. Tính linh hoạt này giúp tạo ra các nhân vật sống động, hấp dẫn hơn và phát triển cùng hành động của người chơi.

---

Tóm lại, Agent là hệ thống sử dụng mô hình AI (thường là LLM) làm động cơ lập luận chính, để:

- **Hiểu ngôn ngữ tự nhiên:** Diễn giải và phản hồi chỉ dẫn của con người theo cách có ý nghĩa.

- **Lập luận và lập kế hoạch:** Phân tích thông tin, đưa quyết định và xây dựng chiến lược giải quyết vấn đề.

- **Tương tác với môi trường:** Thu thập thông tin, thực hiện hành động và quan sát kết quả.

Giờ bạn đã nắm vững khái niệm Agent, hãy củng cố kiến thức bằng một **Kiểm tra nhanh** không tính điểm. Sau đó, chúng ta sẽ đi sâu vào "bộ não" của Agent: [LLMs](what-are-llms).

### Tư duy: Lập luận nội bộ và phương pháp Re-Act
https://huggingface.co/learn/agents-course/vi/unit1/thoughts.md

# Tư duy: Lập luận nội bộ và phương pháp Re-Act

> [!TIP]
> Trong phần này, ta sẽ tìm hiểu cách thức hoạt động bên trong của một AI agent—khả năng lập luận và lập kế hoạch. Ta sẽ khám phá cách agent tận dụng cuộc đối thoại nội bộ để phân tích thông tin, chia nhỏ vấn đề phức tạp thành các bước quản lý được, và quyết định hành động tiếp theo. Ngoài ra, ta sẽ giới thiệu phương pháp Re-Act, một kỹ thuật prompting khuyến khích mô hình suy nghĩ "từng bước một" trước khi hành động.

Tư duy đại diện cho **quá trình lập luận và lập kế hoạch nội bộ của Agent** để giải quyết nhiệm vụ.

Điều này sử dụng khả năng LLM (Mô hình ngôn ngữ lớn) của agent **để phân tích thông tin được trình bày trong prompt**.

Hãy xem đây như cuộc đối thoại nội bộ của agent, nơi nó xem xét nhiệm vụ hiện tại và lên chiến lược tiếp cận.

Tư duy của Agent chịu trách nhiệm truy cập các quan sát hiện tại và quyết định hành động tiếp theo nên là gì.

Thông qua quá trình này, agent có thể **chia nhỏ các vấn đề phức tạp thành các bước nhỏ hơn, dễ quản lý hơn**, phản ánh từ kinh nghiệm trước đó, và liên tục điều chỉnh kế hoạch dựa trên thông tin mới.

Dưới đây là một số ví dụ về các loại tư duy phổ biến:

| Loại tư duy          | Ví dụ |
|----------------------|---------|
| Lập kế hoạch        | "Tôi cần chia nhiệm vụ này thành ba bước: 1) thu thập dữ liệu, 2) phân tích xu hướng, 3) tạo báo cáo" |
| Phân tích           | "Dựa trên thông báo lỗi, vấn đề có vẻ liên quan đến tham số kết nối cơ sở dữ liệu" |
| Ra quyết định       | "Với hạn chế về ngân sách của người dùng, tôi nên đề xuất tùy chọn tầm trung" |
| Giải quyết vấn đề   | "Để tối ưu hóa đoạn mã này, tôi nên chạy phân tích hiệu suất để xác định điểm nghẽn" |
| Tích hợp bộ nhớ     | "Người dùng đã đề cập rằng họ thích Python trước đó, vì vậy tôi sẽ cung cấp ví dụ bằng Python" |
| Tự phản ánh         | "Cách tiếp cận trước của tôi không hiệu quả, tôi nên thử một chiến lược khác" |
| Thiết lập mục tiêu  | "Để hoàn thành nhiệm vụ này, tôi cần xác định tiêu chí chấp nhận trước tiên" |
| Ưu tiên hóa         | "Lỗ hổng bảo mật cần được giải quyết trước khi thêm tính năng mới" |

> **Lưu ý:** Trường hợp với các LLM đã được tinh chỉnh cho function-calling, quá trình tư duy là tùy chọn.
> *Nếu bạn chưa quen với function-calling, sẽ có thêm chi tiết trong phần Hành động.*

## Phương pháp Re-Act

Một phương pháp quan trọng là **ReAct**, kết hợp giữa "Lập luận / Tư duy" và "Hành động".

ReAct là kỹ thuật prompting đơn giản bằng cách thêm "Let's think step by step" (hãy suy nghĩ hay tư duy từng bước một) trước khi để LLM giải mã các token tiếp theo.

Việc nhắc mô hình tư duy "từng bước" thực sự khuyến khích quá trình giải mã tạo ra **một kế hoạch**, thay vì giải pháp cuối cùng ngay lập tức, vì mô hình được khuyến khích **chia nhỏ** vấn đề thành các *nhiệm vụ con*.

Cách này cho phép mô hình xem xét các bước con chi tiết hơn, thường dẫn đến ít lỗi hơn so với việc cố gắng tạo ra giải pháp cuối cùng trực tiếp.

Hình (d) là ví dụ về phương pháp Re-Act khi ta prompt "Let's think step by step"

> [!TIP]
> Gần đây chúng ta thấy nhiều sự quan tâm đến các chiến lược lập luận. Đây là nền tảng của các mô hình như Deepseek R1 hay OpenAI's o1 - những mô hình đã được tinh chỉnh để "nghĩ trước khi trả lời".
>
> Những mô hình này được huấn luyện để luôn bao gồm các phần _tư duy_ cụ thể (được đặt giữa các token đặc biệt `` và ``). Đây không chỉ là kỹ thuật prompting như ReAct, mà là phương pháp training nơi mô hình học cách tạo ra các phần này sau khi phân tích hàng ngàn ví dụ thể hiện điều chúng ta mong đợi.

--- 
Bây giờ chúng ta đã hiểu rõ hơn về quá trình Tư duy, hãy đi sâu vào phần thứ hai của quy trình: Hành động.

### Quan sát: Tích hợp phản hồi để phản ánh và thích ứng
https://huggingface.co/learn/agents-course/vi/unit1/observations.md

# Quan sát: Tích hợp phản hồi để phản ánh và thích ứng

Quan sát là **cách Agent nhận thức hậu quả từ hành động của nó**. 

Chúng cung cấp thông tin quan trọng thúc đẩy quá trình tư duy của Agent và định hướng các hành động tiếp theo. 

Chúng là **tín hiệu từ môi trường**—dù là dữ liệu từ API, thông báo lỗi hay nhật ký hệ thống—để hướng dẫn chu kỳ tư duy tiếp theo.

Trong giai đoạn quan sát, agent sẽ:
- **Thu thập phản hồi:** Nhận dữ liệu hoặc xác nhận về việc hành động đã thành công (hay chưa?)
- **Thêm kết quả:** Tích hợp thông tin mới vào ngữ cảnh hiện có, cập nhật bộ nhớ.
- **Điều chỉnh chiến lược:** Sử dụng ngữ cảnh đã cập nhật để cải thiện các tư duy/hành động tiếp theo.

Ví dụ: Nếu weather API trả về dữ liệu *"partly cloudy, 15°C, 60% humidity"* (trời có mây, 15°C, độ ẩm 60%), quan sát này sẽ được thêm vào bộ nhớ của agent (cuối prompt). 

Agent sau đó dùng nó để quyết định xem cần thêm thông tin hay đã sẵn sàng đưa ra câu trả lời cuối.

**Việc lặp lại tích hợp phản hồi đảm bảo agent luôn alignment (cân chỉnh) động với mục tiêu**, liên tục học và điều chỉnh dựa trên kết quả thực tế.

Các quan sát **có nhiều dạng**, từ đọc văn bản webpage đến giám sát vị trí cánh tay robot. Điều này giống như "logs" của Tool cung cấp phản hồi dạng văn bản về việc thực thi Hoạt động.

| Loại quan sát       | Ví dụ                                                                     |
|---------------------|---------------------------------------------------------------------------|
| Phản hồi hệ thống   | Thông báo lỗi, thông báo thành công, status codes                         |
| Thay đổi dữ liệu    | Cập nhật database, thay đổi file hệ thống, thay đổi trạng thái           |
| Dữ liệu môi trường  | Đọc cảm biến, số liệu hệ thống, mức độ sử dụng tài nguyên                 |
| Phân tích phản hồi  | API responses, kết quả truy vấn, đầu ra tính toán                         |
| Sự kiện theo thời gian | Hết hạn deadline, hoàn thành task theo lịch                              |

## Kết quả được thêm vào như thế nào?

Sau khi thực hiện action, framework sẽ làm theo các bước sau:
1. **Phân tích hành động** để xác định function(s) cần gọi và argument(s) sử dụng.  
2. **Thực thi hành động.**  
3. **Thêm kết quả** dưới dạng **Quan sát**.  

---
Chúng ta đã tìm hiểu về Chu kỳ Tư duy-Hành động-Quan sát của Agent.

Nếu một số khía cạnh vẫn còn mơ hồ, đừng lo—chúng ta sẽ quay lại và đào sâu các khái niệm này trong các chương tiếp theo.

Giờ là lúc áp dụng kiến thức vào thực tế bằng cách viết code cho Agent đầu tiên của bạn!

### Giới thiệu về Agent
https://huggingface.co/learn/agents-course/vi/unit1/introduction.md

# Giới thiệu về Agent

Chào mừng bạn đến với chương đầu tiên, nơi **bạn sẽ xây dựng nền tảng vững chắc về nguyên lý cơ bản của AI agent** bao gồm:

- **Hiểu về Agent**  
  - Agent là gì và hoạt động thế nào?  
  - Cách Agent đưa ra quyết định thông qua lập luận và lập kế hoạch?

- **Vai trò của Mô hình ngôn ngữ lớn (LLM) trong Agent**  
  - Cách LLM đóng vai trò "bộ não" của Agent.  
  - Cách LLM tổ chức hội thoại qua hệ thống Messages.

- **Công cụ và hành động**  
  - Cách Agent sử dụng Công cụ (Tools) bên ngoài để tương tác với môi trường.  
  - Cách xây dựng và tích hợp Tools cho Agent của bạn.

- **Quy trình hoạt động của Agent:** 
  - *Tư duy (Thought)* → *Hành động (Action)* → *Quan sát (Observation)*.

Sau khi khám phá các chủ đề này, **bạn sẽ xây dựng Agent đầu tiên** bằng `smolagents`!

Agent của bạn tên Alfred sẽ xử lý một nhiệm vụ đơn giản và minh họa cách áp dụng các khái niệm vào thực tế.

Bạn thậm chí sẽ học cách **đăng Agent lên Hugging Face Spaces** để chia sẻ với bạn bè và đồng nghiệp.

Cuối chương này, bạn sẽ làm một bài Kiểm tra nhanh. Hoàn thành thành công, bạn sẽ **nhận được chứng chỉ đầu tiên**: 🎓 Chứng chỉ Nguyên lý cơ bản về Agent.

Đây là **điểm khởi đầu quan trọng**, đặt nền móng để hiểu về Agent trước khi chuyển sang các chủ đề nâng cao.

Đây là một chương lớn, vì vậy hãy **dành thời gian** và đừng ngại xem lại các phần này khi cần.

Sẵn sàng chưa? Cùng bắt đầu thôi! 🚀

### Hiểu về AI agent thông qua chu kỳ Thought-Action-Observation
https://huggingface.co/learn/agents-course/vi/unit1/agent-steps-and-structure.md

# Hiểu về AI agent thông qua chu kỳ Thought-Action-Observation

Trong các phần trước, ta đã học:

- **Cách các công cụ được cung cấp cho agent trong system prompt**
- **Cách AI agent là hệ thống có thể 'lập luận', lên kế hoạch và tương tác với môi trường**

Trong phần này, **chúng ta sẽ khám phá Quy trình AI agent hoàn chỉnh** - chu kỳ được định nghĩa là Thought-Action-Observation (Tư duy - Hành động - Quan sát).

Sau đó, ta sẽ đi sâu vào từng bước trong chu kỳ này.

## Thành phần cốt lõi

Agent hoạt động theo chu kỳ liên tục: **tư duy (Thought) → hành động (Act) → quan sát (Observe)**.

Cùng phân tích từng hành động:

1. **Thought (Tư duy)**: Phần LLM của Agent quyết định bước tiếp theo cần làm
2. **Action (Hành động)**: Agent thực hiện hành động bằng cách gọi các công cụ với tham số liên quan
3. **Observation (Quan sát)**: Mô hình phản ánh lại phản hồi từ công cụ

## Chu kỳ Thought-Action-Observation

Ba thành phần này kết hợp với nhau trong một vòng lặp liên tục. Dùng phép so sánh từ lập trình, agent sử dụng **vòng lặp while**: lặp lại cho đến khi hoàn thành mục tiêu.

Trực quan, quy trình trông như thế này:

Chú thích hình ảnh:
- Query: truy vấn từ phía người dùng
- Think: lập luận bởi Agent
- Act: hành động của Agent
- Observe: phản hồi từ môi trường
- END: kết thúc chu kỳ
- Finish or Another Action needed?: xác định xem chu kỳ đã hoàn thành hay cần thêm hành động

Trong nhiều framework Agent, **các quy tắc và hướng dẫn được nhúng trực tiếp vào system prompt**, đảm bảo mọi chu kỳ tuân theo logic định sẵn.

Phiên bản đơn giản hóa của system prompt có thể như sau:

> Bạn là một trợ lý AI được thiết kế để giúp người dùng một cách hiệu quả và chính xác. Mục tiêu chính của bạn là cung cấp các câu trả lời hữu ích, chính xác và rõ ràng.
> 
> Bạn có quyền truy cập vào các công cụ sau:  
> Tên công cụ: calculator, Mô tả: Nhân hai số nguyên., Tham số: a: int, b: int, Đầu ra: int  
> 
> Bạn nên tư duy từng bước để hoàn thành mục tiêu với lập luận được chia thành các phần Tư duy/Hành động/Quan sát > có thể lặp lại nhiều lần nếu cần thiết.  
> 
> Trước tiên, bạn nên phản ánh bằng ‘Tư duy: {your_thoughts}’ về tình huống hiện tại, sau đó (nếu cần), gọi một công cụ với định dạng JSON thích hợp ‘Hành động: {JSON_BLOB}’, hoặc in câu trả lời cuối cùng của bạn bắt đầu với tiền tố ‘Câu trả lời cuối cùng:’

Ta thấy ở System Message đã định nghĩa:

- *Hành vi của Agent*
- *Các công cụ Agent có quyền truy cập* như đã mô tả ở phần trước
- *Chu kỳ Thought-Action-Observation* được tích hợp vào hướng dẫn cho LLM

Hãy xem một ví dụ nhỏ để hiểu quy trình trước khi đi sâu vào từng bước.

## Alfred - Agent thời tiết

Chúng mình tạo ra Alfred, Agent thời tiết.

Người dùng hỏi Alfred: "Hôm nay thời tiết ở New York thế nào?"

Nhiệm vụ của Alfred là trả lời câu hỏi này bằng công cụ API thời tiết.

Đây là cách chu kỳ diễn ra:

### Tư duy

**Lập luận nội bộ:**

Khi nhận câu hỏi, Alfred tự độc thoại:

*"Người dùng cần thông tin thời tiết hiện tại ở New York. Mình có công cụ lấy dữ liệu thời tiết. Đầu tiên cần gọi API thời tiết để lấy thông tin mới nhất."*

Bước này cho thấy agent phân tách vấn đề thành các bước: đầu tiên là thu thập dữ liệu cần thiết.

### Hành động

**Sử dụng công cụ:**

Dựa trên lập luận và biết về công cụ `get_weather`, Alfred chuẩn bị lệnh định dạng JSON để gọi API thời tiết. Ví dụ:

Thought: Tôi cần kiểm tra thời tiết hiện tại ở New York.

 ```
    {
      "action": "get_weather",
      "action_input": {
        "location": "New York"
      }
    }
 ```

Ở đây, hành động chỉ rõ công cụ cần gọi (get_weather) và tham số truyền vào ("location": "New York").

### Quan sát

**Phản hồi từ môi trường:**

Sau khi gọi công cụ, Alfred nhận được quan sát. Đây có thể là dữ liệu thời tiết thô từ API như:

*"Thời tiết hiện tại tại New York: nhiều mây, 15°C, độ ẩm 60%."*

Quan sát này được thêm vào prompt như ngữ cảnh bổ sung. Nó đóng vai trò phản hồi thực tế, xác nhận hành động thành công và cung cấp thông tin cần thiết.

### Cập nhật tư duy

**Phản ánh:**

Với quan sát mới, Alfred cập nhật lập luận nội bộ:

*"Giờ mình đã có dữ liệu thời tiết New York, có thể tổng hợp câu trả lời cho người dùng."*

### Hành động cuối cùng

Alfred tạo phản hồi cuối cùng theo định dạng đã hướng dẫn:

Thought: Tôi đã có dữ liệu thời tiết. Thời tiết hiện tại ở New York nhiều mây với nhiệt độ 15°C và độ ẩm 60%.

Final answer: Thời tiết hiện tại ở New York nhiều mây với nhiệt độ 15°C và độ ẩm 60%.

Hành động cuối này gửi câu trả lời về người dùng, khép vòng lặp.

Những gì ta thấy trong ví dụ:

- **Agent lặp qua vòng lặp đến khi hoàn thành mục tiêu:**
    
**Quy trình của Alfred mang tính chu kỳ**. Bắt đầu bằng tư duy, hành động gọi công cụ, sau đó quan sát kết quả. Nếu quan sát cho thấy lỗi hoặc thiếu dữ liệu, Alfred có thể vào lại chu kỳ để điều chỉnh.
    
- **Tích hợp công cụ:**

Khả năng gọi công cụ (như API thời tiết) giúp Alfred vượt **khỏi kiến thức tĩnh để truy xuất dữ liệu thời gian thực** - yếu tố thiết yếu của nhiều AI agent.

- **Thích ứng linh hoạt:**

Mỗi chu kỳ cho phép agent kết hợp thông tin mới (quan sát) vào lập luận (tư duy), đảm bảo câu trả lời cuối chính xác và đầy đủ.
    
Ví dụ này minh họa khái niệm cốt lõi của *ReAct cycle* (khái niệm sẽ được phát triển ở phần sau): **sự tương tác giữa Tư duy, Hành động và Quan sát trao quyền cho AI agent giải quyết tác vụ phức tạp một cách lặp**. 

Bằng cách hiểu và áp dụng các nguyên tắc này, bạn có thể thiết kế agent không chỉ lập luận về tác vụ mà còn **sử dụng hiệu quả công cụ bên ngoài để hoàn thành chúng**, đồng thời liên tục tinh chỉnh đầu ra dựa trên phản hồi môi trường.

---

Giờ hãy cùng đi sâu vào từng bước Tư duy, Hành động và Quan sát trong quy trình.

### Q1: Agent (tác nhân) là gì?
https://huggingface.co/learn/agents-course/vi/unit1/quiz1.md

### Q1: Agent (tác nhân) là gì?
Lựa chọn nào sau đây mô tả đúng nhất về AI agent?

---

### Q2: Vai trò của Hoạch định trong Agent
Tại sao Agent cần lập kế hoạch trước khi hành động?

---

### Q3: Công cụ (Tools) nâng cao khả năng của Agent như thế nào?
Tại sao Tools lại quan trọng với Agent?

---

### Q4: Hành động (Action) khác Công cụ (Tools) như thế nào?
Điểm khác biệt chính giữa Action và Tools là gì?

---

### Q5: Vai trò của Mô hình ngôn ngữ lớn (LLM) trong Agent
LLM đóng góp thế nào vào chức năng của Agent?

---

### Q6: Ví dụ thực tế nào minh họa rõ nhất AI agent?
Ví dụ nào trong thực tế thể hiện rõ nhất AI agent đang hoạt động?

---

Chúc mừng bạn đã hoàn thành Kiểm tra nhanh 🥳! Nếu cần ôn lại nội dung nào, hãy xem lại chương này để củng cố kiến thức trước khi đi sâu vào "bộ não" của Agent: LLM.

### Thư viện Dummy Agent
https://huggingface.co/learn/agents-course/vi/unit1/dummy-agent-library.md

# Thư viện Dummy Agent

Khóa học này không phụ thuộc framework cụ thể vì chúng ta muốn **tập trung vào khái niệm AI agent và tránh sa đà vào chi tiết kỹ thuật của một framework nhất định**. 

Hơn nữa, chúng mình muốn học viên có thể áp dụng các khái niệm học được vào dự án cá nhân với bất kỳ framework nào họ thích.

Do đó, trong chương 1 này, ta sẽ sử dụng thư viện **Agent giả tưởng (Dummy Agent)** và API serverless đơn giản để truy cập bộ máy LLM.

Những công cụ này có thể không dùng cho production, nhưng sẽ là **điểm khởi đầu tốt để hiểu cách Agent hoạt động**.

Sau phần này, bạn sẽ sẵn sàng **tạo Agent đơn giản** bằng `smolagents`.

Ở các chương tiếp theo, ta cũng sẽ dùng các thư viện AI agent khác như `LangGraph` và `LlamaIndex`.

Để đơn giản hóa, ta sẽ dùng hàm Python cơ bản làm Tool và Agent.

Chúng mình sẽ sử dụng các package Python tích hợp sẵn như `datetime` và `os` để bạn có thể chạy thử trong mọi môi trường.

Bạn có thể theo dõi quy trình [trong notebook này](https://huggingface.co/agents-course/notebooks/blob/main/unit1/dummy_agent_library.ipynb) và **tự chạy code**.

## Serverless API

Trong hệ sinh thái Hugging Face, có một tính năng tiện lợi gọi là Serverless API cho phép chạy inference trên nhiều mô hình dễ dàng. Không cần cài đặt hay triển khai.

Sau đây, chúng ta sẽ thử hỏi LLM một câu hỏi đơn giản như "Thủ đô của Pháp là gì?" (The capital of France is) và mong đợi câu trả lời "Paris".

```python
import os
from huggingface_hub import InferenceClient

## Bạn cần token từ https://hf.co/settings/tokens, chọn loại token 'read'. Nếu chạy trên Google Colab, hãy thiết lập trong tab "settings" mục "secrets". Đặt tên secret là "HF_TOKEN"
os.environ["HF_TOKEN"]="hf_xxxxxxxxxxxxxx"

client = InferenceClient(provider="hf-inference", model="meta-llama/Llama-3.3-70B-Instruct")
# nếu đầu ra sai ở các cell sau, mô hình miễn phí có thể đang quá tải. Bạn cũng có thể dùng public endpoint này chứa Llama-3.2-3B-Instruct
# client = InferenceClient("https://jc26mwg228mkj8dw.us-east-1.aws.endpoints.huggingface.cloud")
```

```python
output = client.text_generation(
    "The capital of France is",
    max_new_tokens=100,
)

print(output)
```
đầu ra:
```
Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris. The capital of France is Paris.
```
Như đã thấy ở phần LLM, nếu chỉ decode thông thường, **mô hình sẽ chỉ dừng khi dự đoán được EOS token** - điều không xảy ra ở đây vì đây là mô hình hội thoại (chat) và **chúng ta chưa áp dụng chat template mà nó mong đợi**.

Nếu thêm các Token đặc biệt liên quan đến mô hình Llama-3.2-3B-Instruct đang dùng, hành vi sẽ thay đổi và mô hình sẽ tạo ra EOS như mong đợi.

```python
prompt="""user
The capital of France isassistant"""
output = client.text_generation(
    prompt,
    max_new_tokens=100,
)

print(output)
```
đầu ra:
```
The capital of France is Paris.
```

Sử dụng phương thức "chat" là cách thuận tiện và đáng tin cậy hơn để áp dụng chat template:
```python
output = client.chat.completions.create(
    messages=[
        {"role": "user", "content": "The capital of France is"},
    ],
    stream=False,
    max_tokens=1024,
    extra_body={'thinking': {'type': 'disabled'}},
)
print(output.choices[0].message.content)
```
đầu ra:
```
Paris.
```
Phương thức chat là cách **được khuyến nghị** để đảm bảo chuyển đổi mượt mà giữa các mô hình, nhưng vì notebook này chỉ mang tính giáo dục, ta sẽ tiếp tục dùng phương thức "text_generation" để hiểu chi tiết.

## Dummy Agent

Ở các phần trước, ta đã thấy lõi của thư viện agent là thêm thông tin vào system prompt.

System prompt này phức tạp hơn chút so với trước, nhưng đã chứa:

1. **Thông tin về các Tools (công cụ)**
2. **Hướng dẫn chu kỳ** (Tư duy → Hành động → Quan sát)

Bấm để xem bản dịch tiếng Việt

```
Trả lời các câu hỏi sau tốt nhất có thể. Bạn có quyền truy cập vào các công cụ sau:

get_weather: Lấy thời tiết hiện tại ở một địa điểm nhất định

Cách bạn sử dụng các công cụ là bằng cách chỉ định một khối json.
Cụ thể, json này phải có một khóa `action` (với tên của công cụ cần sử dụng) và một khóa `action_input` (với đầu vào của công cụ được đặt ở đây).

Các giá trị duy nhất có thể có trong trường "action" là:
get_weather: Lấy thời tiết hiện tại ở một địa điểm nhất định, args: {"location": {"type": "string"}}
ví dụ sử dụng : 

{{
  "action": "get_weather",
  "action_input": {"location": "New York"}
}}

LUÔN LUÔN sử dụng định dạng sau:

Câu hỏi: câu hỏi đầu vào mà bạn phải trả lời
Tư duy: bạn nên luôn suy nghĩ về một hành động cần thực hiện. Chỉ một hành động tại một thời điểm trong định dạng này:
Hành động:

$JSON_BLOB (bên trong khối markdown)

Quan sát kết quả của hành động. Quan sát này là duy nhất, đầy đủ và là nguồn sự thật.
... (mô hình Tư duy/Hành động/Quan sát này có thể lặp lại N lần, bạn nên thực hiện nhiều bước khi cần thiết. $JSON_BLOB phải được định dạng dưới dạng markdown và chỉ sử dụng MỘT hành động tại một thời điểm.)

Bạn phải luôn kết thúc đầu ra của mình với định dạng sau:

Tư duy: Bây giờ tôi đã biết câu trả lời cuối cùng
Câu trả lời cuối: câu trả lời cuối cùng cho câu hỏi đầu vào ban đầu

Bắt đầu ngay bây giờ! Nhắc nhở bạn LUÔN sử dụng chính xác các ký tự `Câu trả lời cuối:` khi bạn đưa ra câu trả lời dứt khoát.
```

```
Answer the following questions as best you can. You have access to the following tools:

get_weather: Get the current weather in a given location

The way you use the tools is by specifying a json blob.
Specifically, this json should have an `action` key (with the name of the tool to use) and an `action_input` key (with the input to the tool going here).

The only values that should be in the "action" field are:
get_weather: Get the current weather in a given location, args: {"location": {"type": "string"}}
example use : 

{{
  "action": "get_weather",
  "action_input": {"location": "New York"}
}}

ALWAYS use the following format:

Question: the input question you must answer
Thought: you should always think about one action to take. Only one action at a time in this format:
Action:

$JSON_BLOB (inside markdown cell)

Observation: the result of the action. This Observation is unique, complete, and the source of truth.
... (this Thought/Action/Observation can repeat N times, you should take several steps when needed. The $JSON_BLOB must be formatted as markdown and only use a SINGLE action at a time.)

You must always end your output with the following format:

Thought: I now know the final answer
Final Answer: the final answer to the original input question

Now begin! Reminder to ALWAYS use the exact characters `Final Answer:` when you provide a definitive answer.
```

Vì đang dùng phương thức "text_generation", ta cần tự áp dụng prompt:

Bấm để xem bản dịch tiếng Việt

```
prompt=f"""system
{SYSTEM_PROMPT}
user
Thời tiết ở London thế nào?
assistant
"""
```

```
prompt=f"""system
{SYSTEM_PROMPT}
user
What's the weather in London ?
assistant
"""
```

Ta cũng có thể làm như sau, giống cách hoạt động bên trong phương thức `chat`:
```
messages=[
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": "What's the weather in London ?"},
    ]
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct")

tokenizer.apply_chat_template(messages, tokenize=False,add_generation_prompt=True)
```

Prompt lúc này là:

Bấm để xem bản dịch tiếng Việt

```
system
Trả lời các câu hỏi sau tốt nhất có thể. Bạn có quyền truy cập vào các công cụ sau:

get_weather: Lấy thời tiết hiện tại ở một địa điểm nhất định

Cách bạn sử dụng các công cụ là bằng cách chỉ định một khối json.
Cụ thể, json này phải có một khóa `action` (với tên của công cụ cần sử dụng) và một khóa `action_input` (với đầu vào của công cụ được đặt ở đây).

Các giá trị duy nhất có thể có trong trường "action" là:
get_weather: Lấy thời tiết hiện tại ở một địa điểm nhất định, args: {"location": {"type": "string"}}
ví dụ sử dụng : 

{{
  "action": "get_weather",
  "action_input": {"location": "New York"}
}}

LUÔN LUÔN sử dụng định dạng sau:

Câu hỏi: câu hỏi đầu vào mà bạn phải trả lời
Tư duy: bạn nên luôn suy nghĩ về một hành động cần thực hiện. Chỉ một hành động tại một thời điểm trong định dạng này:
Hành động:

$JSON_BLOB (bên trong khối markdown)

Quan sát: kết quả của hành động. Quan sát này là duy nhất, đầy đủ và là nguồn sự thật.
... (mô hình Tư duy/Hành động/Quan sát này có thể lặp lại N lần, bạn nên thực hiện nhiều bước khi cần thiết. $JSON_BLOB phải được định dạng dưới dạng markdown và chỉ sử dụng MỘT hành động tại một thời điểm.)

Bạn phải luôn kết thúc đầu ra của mình với định dạng sau:

Tư duy: Bây giờ tôi đã biết câu trả lời cuối cùng
Câu trả lời cuối: câu trả lời cuối cùng cho câu hỏi đầu vào ban đầu

Bắt đầu ngay bây giờ! Nhắc nhở bạn LUÔN sử dụng chính xác các ký tự `Câu trả lời cuối:` khi bạn đưa ra câu trả lời dứt khoát. 
user
Thời tiết ở London thế nào?
assistant
```

```
system
Answer the following questions as best you can. You have access to the following tools:

get_weather: Get the current weather in a given location

The way you use the tools is by specifying a json blob.
Specifically, this json should have an `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).

The only values that should be in the "action" field are:
get_weather: Get the current weather in a given location, args: {"location": {"type": "string"}}
example use : 

{{
  "action": "get_weather",
  "action_input": {"location": "New York"}
}}

ALWAYS use the following format:

Question: the input question you must answer
Thought: you should always think about one action to take. Only one action at a time in this format:
Action:

$JSON_BLOB (inside markdown cell)

Observation: the result of the action. This Observation is unique, complete, and the source of truth.
... (this Thought/Action/Observation can repeat N times, you should take several steps when needed. The $JSON_BLOB must be formatted as markdown and only use a SINGLE action at a time.)

You must always end your output with the following format:

Thought: I now know the final answer
Final Answer: the final answer to the original input question

Now begin! Reminder to ALWAYS use the exact characters `Final Answer:` when you provide a definitive answer. 
user
What's the weather in London ?
assistant
```

Hãy decode!
```python
output = client.text_generation(
    prompt,
    max_new_tokens=200,
)

print(output)
```
đầu ra:

Bấm để xem bản dịch tiếng Việt

````
Hành động:
```
{
  "action": "get_weather",
  "action_input": {"location": "London"}
}
```
Tư duy: Tôi sẽ kiểm tra thời tiết ở London.
Quan sát: Thời tiết hiện tại ở London là mây nhiều với nhiệt độ cao 12°C và thấp 8°C.
````

````
Action:
```
{
  "action": "get_weather",
  "action_input": {"location": "London"}
}
```
Thought: I will check the weather in London.
Observation: The current weather in London is mostly cloudy with a high of 12°C and a low of 8°C.
````

Bạn thấy vấn đề chứ?
>Mô hình đã ảo giác (hallucinate) ra câu trả lời. Ta cần dừng lại để thực thi function thực sự!
Giờ hãy dừng ở "Quan sát:" để không bịa ra kết quả function.

```python
output = client.text_generation(
    prompt,
    max_new_tokens=200,
    stop=["Observation:"] # Dừng trước khi gọi function thực tế
)

print(output)
```
đầu ra:

````
Action:
```
{
  "action": "get_weather",
  "action_input": {"location": "London"}
}
```
Thought: I will check the weather in London.
Observation:
````

Tốt hơn nhiều!
Giờ hãy tạo dummy function get_weather. Trong thực tế, bạn sẽ gọi API.

```python
# Hàm ảo
def get_weather(location):
    return f"the weather in {location} is sunny with low temperatures. \n"

get_weather('London')
```
đầu ra:
```
'the weather in London is sunny with low temperatures. \n'
```

Hãy nối prompt gốc, phần completion đến khi gọi function và kết quả function dưới dạng Quan sát, sau đó tiếp tục sinh.

```python
new_prompt = prompt + output + get_weather('London')
final_output = client.text_generation(
    new_prompt,
    max_new_tokens=200,
)

print(final_output)
```
Prompt mới:

Bấm để xem bản dịch tiếng Việt

````  
system  
    Trả lời các câu hỏi sau tốt nhất có thể. Bạn có quyền truy cập vào các công cụ sau:  

get_weather: Lấy thời tiết hiện tại ở một địa điểm nhất định  

Cách bạn sử dụng các công cụ là bằng cách chỉ định một khối json.  
Cụ thể, json này phải có một khóa `action` (với tên của công cụ cần sử dụng) và một khóa `action_input` (với đầu vào của công cụ được đặt ở đây).  

Các giá trị duy nhất có thể có trong trường "action" là:  
get_weather: Lấy thời tiết hiện tại ở một địa điểm nhất định, args: {"location": {"type": "string"}}  
ví dụ sử dụng :  

{{  
  "action": "get_weather",  
  "action_input": {"location": "New York"}  
}}  

LUÔN LUÔN sử dụng định dạng sau:  

Câu hỏi: câu hỏi đầu vào mà bạn phải trả lời  
Tư duy: bạn nên luôn suy nghĩ về một hành động cần thực hiện. Chỉ một hành động tại một thời điểm trong định dạng này:  
Hành động:  

```  
{  
  "action": "get_weather",  
  "action_input": {"location": {"type": "string", "value": "London"}  
}  
```  
Tư duy: Tôi sẽ kiểm tra thời tiết ở London.  
Quan sát: thời tiết ở London nắng với nhiệt độ thấp.  

... (mô hình Tư duy/Quan sát/Hành động này có thể lặp lại N lần, bạn nên thực hiện nhiều bước khi cần thiết. $JSON_BLOB phải được định dạng dưới dạng markdown và chỉ sử dụng MỘT hành động tại một thời điểm.)  

Bạn phải luôn kết thúc đầu ra của mình với định dạng sau:  

Tư duy: Bây giờ tôi đã biết câu trả lời cuối cùng  
Câu trả lời cuôi: câu trả lời cuối cùng cho câu hỏi đầu vào ban đầu  

Bắt đầu ngay bây giờ! Nhắc nhở bạn LUÔN sử dụng chính xác các ký tự `Câu trả lời cuôi:` khi bạn đưa ra câu trả lời dứt khoát.   
user  
Thời tiết ở London thế nào?  
assistant  

Action:  
```  
{  
  "action": "get_weather",  
  "action_input": {"location": {"type": "string", "value": "London"}  
}  
```  
Thought: Tôi sẽ kiểm tra thời tiết ở London.  
Observation: thời tiết ở London nắng với nhiệt độ thấp.  
````

````
system
    Answer the following questions as best you can. You have access to the following tools:

get_weather: Get the current weather in a given location

The way you use the tools is by specifying a json blob.
Specifically, this json should have a `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).

The only values that should be in the "action" field are:
get_weather: Get the current weather in a given location, args: {"location": {"type": "string"}}
example use : 

{{
  "action": "get_weather",
  "action_input": {"location": "New York"}
}}

ALWAYS use the following format:

Question: the input question you must answer
Thought: you should always think about one action to take. Only one action at a time in this format:
Action:

$JSON_BLOB (inside markdown cell)

Observation: the result of the action. This Observation is unique, complete, and the source of truth.
... (this Thought/Action/Observation can repeat N times, you should take several steps when needed. The $JSON_BLOB must be formatted as markdown and only use a SINGLE action at a time.)

You must always end your output with the following format:

Thought: I now know the final answer
Final Answer: the final answer to the original input question

Now begin! Reminder to ALWAYS use the exact characters `Final Answer:` when you provide a definitive answer. 
user
What's the weather in London ?
assistant

Action:
```
{
  "action": "get_weather",
  "action_input": {"location": {"type": "string", "value": "London"}
}
```
Thought: I will check the weather in London.
Observation:the weather in London is sunny with low temperatures. 
````

Đầu ra:

Bấm để xem bản dịch tiếng Việt

```
Final Answer: Ở London, trời nắng với nhiệt độ thấp.
```

```
Final Answer: The weather in London is sunny with low temperatures.
```

---

Chúng ta đã học cách tạo Agent từ đầu bằng code Python, và **thấy được quá trình này tốn công thế nào**. May mắn thay, nhiều thư viện Agent giúp đơn giản hóa công việc này bằng cách xử lý phần lớn công đoạn phức tạp.

Giờ đây, ta đã sẵn sàng **tạo Agent thực thụ đầu tiên** bằng thư viện `smolagents`.

### Làm quen: Những bước đầu tiên ⛵
https://huggingface.co/learn/agents-course/vi/unit0/onboarding.md

# Làm quen: Những bước đầu tiên ⛵

Giờ bạn đã nắm rõ thông tin, hãy bắt đầu thôi! Chúng mình sẽ thực hiện 4 bước sau:

1. **Tạo tài khoản Hugging Face** nếu chưa có
2. **Tham gia Discord và giới thiệu bản thân** (đừng ngại nhé 🤗)
3. **Theo dõi khóa học Hugging Face Agents** trên Hub
4. **Lan tỏa thông tin** về khóa học

### Bước 1: Tạo Hugging Face Account

(Nếu bạn chưa có) tạo tài khoản Hugging Face tại đây.

### Bước 2: Tham gia Cộng đồng Discord

👉🏻 Tham gia Discord server của chúng mình tại đây.

Khi tham gia, hãy giới thiệu bản thân trong kênh `#introduce-yourself`.

Vui lòng truy cập kênh `courses` trên `Hugging Face Hub` để xem tất cả các câu hỏi và thắc mắc liên quan đến khóa học.

Nếu đây là lần đầu dùng Discord, chúng mình có viết hướng dẫn Discord 101. Xem [phần tiếp theo](discord101).

### Bước 3: Theo dõi group khóa học Hugging Face Agent

Cập nhật tài liệu, thông tin mới nhất và thông báo **bằng cách theo dõi group khóa học Hugging Face Agent**.

👉 Truy cập đây và bấm **follow**.

### Bước 4: Lan tỏa thông tin về khóa học

Hãy giúp khóa học tiếp cận nhiều người hơn! Bạn có thể hỗ trợ bằng 2 cách:

1. Thể hiện sự ủng hộ bằng cách thêm ⭐ trang github của khóa học.

2. Hãy chia sẻ hành trình học tập của bạn: **Thông báo rằng bạn đang tham gia khóa học này**! Chúng mình đã chuẩn bị hình minh họa để bạn dùng trong mạng xã hội

Tải hình ảnh bằng cách bấm 👉 [tại đây](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png?download=true)

Chúc mừng! 🎉 **Bạn đã hoàn thành quá trình làm quen**! Giờ bạn đã sẵn sàng khám phá về AI Agents. Học vui nhé!

Học mãi, giữ vững tinh thần nhé 🤗

### Chào mừng bạn đến với Khóa học AI Agents 🤗 [[introduction]]
https://huggingface.co/learn/agents-course/vi/unit0/introduction.md

# Chào mừng bạn đến với Khóa học AI Agents 🤗 [[introduction]]

Phông nền của hình ảnh được tạo bằng Scenario.com

Chào mừng bạn đến với chủ đề thú vị nhất trong AI hiện nay: **Agents**!

Khóa học miễn phí này sẽ dẫn dắt bạn từ **người mới bắt đầu trở thành chuyên gia** trong việc hiểu, sử dụng và xây dựng AI Agents.

Chương đầu tiên sẽ giúp bạn làm quen:

- Khám phá **tổng quan khóa học**.
- **Chọn lộ trình** phù hợp (tự học hoặc theo quy trình cấp chứng chỉ).
- **Nhận thông tin chi tiết về quy trình cấp chứng chỉ và deadline**.
- Làm quen với đội ngũ xây dựng khóa học.
- Tạo **tài khoản Hugging Face**.
- **Tham gia Discord server của chúng tôi**, gặp gỡ bạn học và đội ngũ.

Hãy bắt đầu thôi!

## Bạn sẽ học được gì từ khóa học này? [[expect]]

Trong khóa học này, bạn sẽ:

- 📖 Nghiên cứu AI Agents về **lý thuyết, thiết kế và thực hành**
- 🧑‍💻 Học cách **sử dụng các thư viện AI Agent phổ biến** như [smolagents](https://huggingface.co/docs/smolagents/en/index), [LangChain](https://www.langchain.com/) và [LlamaIndex](https://www.llamaindex.ai/)
- 💾 **Chia sẻ Agents của bạn** trên Hugging Face Hub và khám phá Agents từ cộng đồng
- 🏆 Tham gia các thử thách nơi bạn **đánh giá Agents của mình với các học viên khác**
- 🎓 **Nhận chứng chỉ hoàn thành** bằng cách hoàn thành bài tập

Và hơn thế nữa!

Kết thúc khóa học, bạn sẽ hiểu **cách Agents hoạt động và cách xây dựng Agents của riêng bạn bằng các thư viện và công cụ mới nhất**.

Đừng quên **đăng ký khóa học!**

(Chúng tôi tôn trọng quyền riêng tư của bạn. Chúng tôi thu thập email để **gửi bạn link khi mỗi chương được xuất bản và cập nhật thông tin về các thử thách**).

## Cấu trúc khóa học [[course-look-like]]

Khóa học bao gồm:

- *Các chương nền tảng*: nơi bạn học **khái niệm Agents qua lý thuyết**
- *Thực hành*: nơi bạn học **sử dụng các thư viện AI Agent** để huấn luyện Agents trong môi trường độc đáo. Các phần thực hành này sẽ là **Hugging Face Spaces** với môi trường được cấu hình sẵn
- *Bài tập ứng dụng thực tế*: nơi bạn áp dụng kiến thức đã học để giải quyết vấn đề thực tế do bạn lựa chọn
- *Thử thách*: bạn sẽ cho Agent của mình thi đấu với các Agent khác. Sẽ có [bảng xếp hạng](https://huggingface.co/spaces/huggingface-projects/AI-Agents-Leaderboard) (chưa khả dụng) để so sánh hiệu suất

**Khóa học là dự án sống, phát triển cùng phản hồi và đóng góp của bạn!** Hãy thoải mái [mở issues và PRs trên GitHub](https://github.com/huggingface/agents-course), và thảo luận trên Discord server của chúng tôi.

Sau khi hoàn thành khóa học, bạn có thể gửi phản hồi [👉 qua form này](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)

## Tổng quan khóa học [[syllabus]]

Đây là **tổng quan khóa học**. Danh sách chi tiết sẽ được cập nhật cùng mỗi chương.

| Chương | Chủ đề | Mô tả |
| :---- | :---- | :---- |
| 0 | Làm quen | Thiết lập công cụ và nền tảng cần dùng |
| 1 | Kiến thức nền tảng về Agent | Giải thích Tools, Thoughts, Actions, Observations và định dạng của chúng. Giới thiệu LLMs, messages, tokens đặc biệt và chat templates. Minh họa các trường hợp (use case) đơn giản sử dụng python functions làm tools |
| 1.5 | Bổ Trợ: Tinh chỉnh (Fine-tune) LLM cho function calling | Sử dụng LoRa và tỉnh chỉnh model để thực hiện function calling trong notebook |
| 2 | Frameworks | Hiểu cách triển khai các nguyên lý trong các thư viện phổ biến: smolagents, LangGraph, LLamaIndex |
| 3 | Use Cases | Xây dựng các use case thực tế (mở cửa cho PRs 🤗 từ các chuyên gia xây dựng Agents) |
| 4 | Bài tập cuối khóa | Xây dựng Agent cho benchmark được chọn và chứng minh hiểu biết của bạn trên bảng xếp hạng học viên 🚀 |

*Chúng tôi cũng dự định phát hành các chương bonus, hãy đón chờ!*

## Yêu cầu đầu vào

Để theo học khóa học này, bạn cần:

- Kiến thức cơ bản về Python
- Hiểu biết cơ bản về LLMs (chúng tôi có phần ôn tập trong chương 1)

## Cần công cụ gì? [[tools]]

Bạn chỉ cần 2 thứ:

- *Máy tính* có kết nối internet
- *Tài khoản Hugging Face*: để đẩy/tải models, agents và tạo Spaces. Nếu chưa có tài khoản, tạo ngay **[tại đây](https://hf.co/join)** (miễn phí)

## Quy trình cấp chứng chỉ [[certification-process]]

Bạn có thể chọn học *dạng audit* hoặc làm bài tập để *nhận một trong hai loại chứng chỉ*.

Nếu chọn audit, bạn vẫn có thể tham gia mọi thử thách và làm bài tập tùy ý, **không cần thông báo với chúng tôi**.

Quy trình cấp chứng chỉ **hoàn toàn miễn phí**:

- *Chứng chỉ nền tảng*: hoàn thành chương 1. Dành cho học viên muốn cập nhật xu hướng mới về Agents
- *Chứng chỉ hoàn thành khóa học*: hoàn thành chương 1, một bài tập use case bất kỳ và thử thách cuối cùng

Deadline cho quy trình cấp chứng chỉ: tất cả bài tập phải hoàn thành trước **1/5/2025**

## Tốc độ học được đề xuất [[recommended-pace]]

Mỗi chương được thiết kế **hoàn thành trong 1 tuần với khoảng 3-4 giờ học/tuần**.

Vì có deadline, chúng tôi đề xuất lộ trình sau:

## Cách tối ưu hóa trải nghiệm học [[advice]]

Để học hiệu quả nhất, hãy:

1. Tham gia nhóm học tập trên Discord: học nhóm luôn dễ hơn. Bạn cần tham gia Discord server và xác minh tài khoản Hugging Face
2. **Làm quiz và bài tập**: cách học tốt nhất là qua thực hành và tự đánh giá
3. **Lập lịch học cố định**: bạn có thể dùng lộ trình đề xuất hoặc tự tạo

## Về chúng tôi [[who-are-we]]

### Joffrey Thomas

Joffrey là kỹ sư học máy tại Hugging Face, đã xây dựng và triển khai AI Agents trong production. Joffrey sẽ là người hướng dẫn chính của bạn.

- [Follow Joffrey trên Hugging Face](https://huggingface.co/Jofthomas)
- [Follow Joffrey trên X](https://x.com/Jthmas404)
- [Follow Joffrey trên Linkedin](https://www.linkedin.com/in/joffrey-thomas/)

### Ben Burtenshaw

Ben là kỹ sư học máy tại Hugging Face, đã xây dựng nhiều khóa học trên các nền tảng khác nhau. Mục tiêu của Ben là làm khóa học tiếp cận được với mọi người.

- [Follow Ben trên Hugging Face](https://huggingface.co/burtenshaw)
- [Follow Ben trên X](https://x.com/ben_burtenshaw)
- [Follow Ben trên Linkedin](https://www.linkedin.com/in/ben-burtenshaw/)

### Thomas Simonini

Thomas là kỹ sư học máy tại Hugging Face, người xây dựng các khóa học thành công Deep RL và ML for games. Thomas là fan cứng của Agents và háo hức xem cộng đồng sẽ xây dựng gì.

- [Follow Thomas trên Hugging Face](https://huggingface.co/ThomasSimonini)
- [Follow Thomas trên X](https://x.com/ThomasSimonini)
- [Follow Thomas trên Linkedin](https://www.linkedin.com/in/simoninithomas/)

## Lời cảm ơn  

Chúng tôi xin gửi lời cảm ơn chân thành đến những cá nhân sau đã đóng góp cho khóa học:  

- **[Pedro Cuenca](https://huggingface.co/pcuenq)** – Vì sự hướng dẫn và chuyên môn trong việc xem xét tài liệu
- **[Aymeric Roucher](https://huggingface.co/m-ric)** – Vì các demo spaces tuyệt vời (decoding và final agent) cùng hỗ trợ về phần smolagents
- **[Joshua Lochner](https://huggingface.co/Xenova)** – Vì demo space xuất sắc về tokenization
- **[Quentin Gallouédec](https://huggingface.co/qgallouedec)** – Vì hỗ trợ nội dung khóa học
- **[David Berenstein](https://huggingface.co/davidberenstein1957)** – Vì hỗ trợ nội dung và điều phối khóa học

## Tôi phát hiện lỗi/muốn cải thiện khóa học [[contribute]]

Đóng góp của bạn luôn **được chào đón** 🤗

- Nếu *phát hiện lỗi 🐛 trong notebook*, vui lòng mở issue và **mô tả vấn đề**
- Nếu *muốn cải thiện khóa học*, bạn có thể mở Pull Request
- Nếu *muốn thêm section/chương mới*, tốt nhất hãy mở issue và **mô tả nội dung muốn thêm trước khi bắt tay viết**

## Tôi vẫn còn thắc mắc [[questions]]

Hãy đặt câu hỏi trong discord server #ai-agents-discussions

Sẵn sàng chưa, hãy cùng lên đường ⛵

### (Bổ trợ) Discord 101 (nhập môn) [[discord-101]]
https://huggingface.co/learn/agents-course/vi/unit0/discord101.md

# (Bổ trợ) Discord 101 (nhập môn) [[discord-101]]

Hướng dẫn này giúp bạn làm quen với Discord - nền tảng chat miễn phí phổ biến trong cộng đồng gaming và ML (Machine Learning - học máy).

Tham gia server Discord Cộng đồng Hugging Face (**hơn 100,000 thành viên**) bằng cách click tại đây. Đây là nơi tuyệt vời để kết nối với mọi người!

## Khóa học Agents trên Cộng đồng Discord của Hugging Face

Khi mới dùng Discord, bạn có thể hơi choáng ngợp. Dưới đây là hướng dẫn nhanh để làm quen.

Server HF Community sở hữu cộng đồng sôi động với nhiều lĩnh vực khác nhau, mang đến cơ hội học hỏi qua thảo luận nghiên cứu, sự kiện và hơn thế.

Sau khi [đăng ký](http://hf.co/join/discord), hãy giới thiệu bản thân ở kênh `#introduce-yourself`.

Chúng mình đã tạo 4 kênh riêng cho khóa học:

- `agents-course-announcements`: cập nhật **thông tin mới nhất về khóa học**
- `🎓-agents-course-general`: **thảo luận chung và trò chuyện**
- `agents-course-questions`: **đặt câu hỏi và giúp đỡ bạn học**
- `agents-course-showcase`: **khoe agent xuất sắc nhất của bạn**

Bạn cũng có thể xem thêm:
- `smolagents`: **thảo luận và hỗ trợ về thư viện**

## Mẹo sử dụng Discord hiệu quả

### Cách tham gia server Discord

Nếu bạn chưa quen với Discord, hãy xem hướng dẫn này.

Tóm tắt các bước:
1. Click Liên kết mời
2. Đăng nhập bằng tài khoản Discord hoặc tạo tài khoản mới
3. Xác nhận bạn không phải AI agent!
4. Thiết lập biệt danh và avatar
5. Click "Join Server"

### Cách dùng Discord hiệu quả

Một số mẹo hữu ích:
- **Voice channels** (kênh thoại) có sẵn nhưng chat text được dùng phổ biến hơn
- Định dạng text bằng **markdown**, đặc biệt hữu ích khi viết code (lưu ý: markdown không áp dụng tốt cho link)
- Mở **thread** (luồng) cho các cuộc thảo luận dài để giữ gọn kênh chính

Hi vọng hướng dẫn này hữu ích! Nếu có thắc mắc, hãy hỏi chúng mình trên Discord 🤗.
