diff --git a/vi/7_inference/README.md b/vi/7_inference/README.md
new file mode 100644
index 00000000..14af9a26
--- /dev/null
+++ b/vi/7_inference/README.md
@@ -0,0 +1,36 @@
+# Suy luận
+
+Suy luận là quá trình sử dụng mô hình ngôn ngữ đã được huấn luyện để tạo ra các dự đoán hoặc phản hồi. Mặc dù suy luận có vẻ đơn giản, nhưng triển khai các mô hình một cách hiệu quả ở quy mô lớn đòi hỏi phải xem xét kỹ lưỡng nhiều yếu tố như hiệu suất, chi phí và độ tin cậy. Các Mô hình Ngôn ngữ Lớn (LLMs) mang lại những thách thức đặc biệt do kích thước và yêu cầu tính toán của chúng.
+
+Chúng ta sẽ khám phá cả hai phương pháp đơn giản và sẵn sàng cho sản xuất bằng cách sử dụng thư viện [`transformers`](https://huggingface.co/docs/transformers/index) và [`text-generation-inference`](https://github.com/huggingface/text-generation-inference), hai framework phổ biến cho suy luận LLM. Đối với các triển khai sản xuất, chúng ta sẽ tập trung vào Suy luận Sinh văn Bằng Văn bản (TGI), cung cấp khả năng phục vụ tối ưu.
+
+## Tổng quan về Module
+
+Suy luận LLM có thể được phân thành hai phương pháp chính: suy luận dựa trên pipeline đơn giản cho phát triển và thử nghiệm, và các giải pháp phục vụ tối ưu cho triển khai sản xuất. Chúng ta sẽ đề cập đến cả hai phương pháp, bắt đầu với phương pháp pipeline đơn giản và tiến tới các giải pháp sẵn sàng cho sản xuất.
+
+## Nội dung
+
+### 1. [Suy luận Pipeline Cơ bản](./pipeline_inference.md)
+
+Học cách sử dụng pipeline Hugging Face Transformers cho suy luận cơ bản. Chúng ta sẽ tìm hiểu cách thiết lập pipeline, cấu hình các tham số sinh văn và các thực hành tốt nhất cho phát triển cục bộ. Phương pháp pipeline là lựa chọn hoàn hảo cho việc tạo mẫu và các ứng dụng quy mô nhỏ. [Bắt đầu học](./pipeline_inference.md).
+
+### 2. [Suy luận Sản xuất với TGI](./tgi_inference.md)
+
+Học cách triển khai mô hình cho sản xuất bằng cách sử dụng Suy luận Sinh văn Bằng Văn bản. Chúng ta sẽ khám phá các kỹ thuật phục vụ tối ưu, chiến lược batching và giải pháp giám sát. TGI cung cấp các tính năng sẵn sàng cho sản xuất như kiểm tra tình trạng, số liệu và các tùy chọn triển khai Docker. [Bắt đầu học](./text_generation_inference.md).
+
+### Sổ tay Bài tập
+
+| Tiêu đề | Mô tả | Bài tập | Liên kết | Colab |
+| ----------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| Suy luận Pipeline | Suy luận cơ bản với pipeline transformers | 🐢 Thiết lập pipeline cơ bản
🐕 Cấu hình tham số sinh văn
🦁 Tạo máy chủ web đơn giản | [Liên kết](./notebooks/basic_pipeline_inference.ipynb) | [Colab](https://githubtocolab.com/huggingface/smol-course/tree/main/7_inference/notebooks/basic_pipeline_inference.ipynb) |
+| Triển khai TGI | Triển khai sản xuất với TGI | 🐢 Triển khai mô hình với TGI
🐕 Cấu hình tối ưu hóa hiệu suất
🦁 Thiết lập giám sát và mở rộng | [Liên kết](./notebooks/tgi_deployment.ipynb) | [Colab](https://githubtocolab.com/huggingface/smol-course/tree/main/7_inference/notebooks/tgi_deployment.ipynb) |
+
+## Tài nguyên
+
+- [Hướng dẫn Pipeline Hugging Face.](https://huggingface.co/docs/transformers/en/pipeline_tutorial)
+- [Tài liệu Suy luận Sinh văn Bằng Văn bản.](https://huggingface.co/docs/text-generation-inference/en/index)
+- [Hướng dẫn Pipeline WebServer.](https://huggingface.co/docs/transformers/en/pipeline_tutorial#using-pipelines-for-a-webserver)
+- [Kho lưu trữ TGI trên GitHub.](https://github.com/huggingface/text-generation-inference)
+- [Tài liệu Triển khai Mô hình Hugging Face.](https://huggingface.co/docs/inference-endpoints/index)
+- [vLLM: Phục vụ LLM Tốc độ Cao.](https://github.com/vllm-project/vllm)
+- [Tối ưu hóa Suy luận Transformer.](https://huggingface.co/blog/optimize-transformer-inference)
\ No newline at end of file
diff --git a/vi/7_inference/inference_pipeline.md b/vi/7_inference/inference_pipeline.md
new file mode 100644
index 00000000..02195156
--- /dev/null
+++ b/vi/7_inference/inference_pipeline.md
@@ -0,0 +1,169 @@
+# Suy luận cơ bản với Pipeline Transformers
+
+Abstraction `pipeline` trong 🤗 Transformers cung cấp một cách đơn giản để thực hiện suy luận với bất kỳ mô hình nào từ Hugging Face Hub. Nó xử lý tất cả các bước tiền xử lý và hậu xử lý, giúp người dùng dễ dàng sử dụng mô hình mà không cần kiến thức sâu về kiến trúc hay yêu cầu của chúng.
+
+## Cách hoạt động của Pipelines
+
+Pipelines của Hugging Face đơn giản hóa quy trình học máy bằng cách tự động hóa ba giai đoạn quan trọng giữa đầu vào thô và đầu ra có thể đọc được:
+
+**Giai đoạn Tiền xử lý**
+Pipeline sẽ chuẩn bị các đầu vào thô cho mô hình. Điều này thay đổi tùy thuộc vào loại đầu vào:
+- Đầu vào văn bản trải qua quá trình phân tách (tokenization) để chuyển các từ thành các ID token phù hợp với mô hình
+- Hình ảnh được thay đổi kích thước và chuẩn hóa để phù hợp với yêu cầu của mô hình
+- Âm thanh được xử lý thông qua việc trích xuất tính năng để tạo ra phổ tần (spectrograms) hoặc các biểu diễn khác
+
+**Suy luận Mô hình**
+Trong quá trình chạy mô hình, pipeline:
+- Tự động xử lý batching các đầu vào để tăng hiệu quả
+- Đặt tính toán lên thiết bị tối ưu (CPU/GPU)
+- Áp dụng các tối ưu hóa hiệu suất như suy luận với độ chính xác nửa (FP16) khi được hỗ trợ
+
+**Giai đoạn Hậu xử lý**
+Cuối cùng, pipeline chuyển đổi đầu ra thô từ mô hình thành kết quả hữu ích:
+- Giải mã các ID token trở lại thành văn bản có thể đọc được
+- Biến đổi các logits thành điểm xác suất
+- Định dạng đầu ra theo tác vụ cụ thể (ví dụ: nhãn phân loại, văn bản sinh ra)
+
+Abstraction này giúp bạn tập trung vào logic ứng dụng trong khi pipeline xử lý sự phức tạp kỹ thuật của suy luận mô hình.
+
+## Cách sử dụng cơ bản
+
+Dưới đây là cách sử dụng pipeline để tạo văn bản:
+
+```python
+from transformers import pipeline
+
+# Tạo pipeline với một mô hình cụ thể
+generator = pipeline(
+ "text-generation",
+ model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+ torch_dtype="auto",
+ device_map="auto"
+)
+
+# Tạo văn bản
+response = generator(
+ "Write a short poem about coding:",
+ max_new_tokens=100,
+ do_sample=True,
+ temperature=0.7
+)
+print(response[0]['generated_text'])
+```
+
+## Các tùy chọn cấu hình chính
+
+### Tải mô hình
+```python
+# Suy luận trên CPU
+generator = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-1.7B-Instruct", device="cpu")
+
+# Suy luận trên GPU
+generator = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-1.7B-Instruct", device=0)
+
+# Đặt thiết bị tự động
+generator = pipeline(
+ "text-generation",
+ model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+ device_map="auto",
+ torch_dtype="auto"
+)
+```
+
+### Tham số tạo văn bản
+
+```python
+response = generator(
+ "Translate this to French:",
+ max_new_tokens=100, # Độ dài tối đa của văn bản sinh ra
+ do_sample=True, # Sử dụng sampling thay vì greedy decoding
+ temperature=0.7, # Điều chỉnh độ ngẫu nhiên (cao hơn = ngẫu nhiên hơn)
+ top_k=50, # Giới hạn đến top k token
+ top_p=0.95, # Ngưỡng sampling hạt nhân
+ num_return_sequences=1 # Số lượng văn bản sinh ra khác nhau
+)
+```
+
+## Xử lý nhiều đầu vào
+
+Pipelines có thể xử lý nhiều đầu vào một cách hiệu quả thông qua batching:
+
+```python
+# Chuẩn bị nhiều prompt
+prompts = [
+ "Write a haiku about programming:",
+ "Explain what an API is:",
+ "Write a short story about a robot:"
+]
+
+# Xử lý tất cả các prompt một cách hiệu quả
+responses = generator(
+ prompts,
+ batch_size=4, # Số lượng prompt xử lý cùng một lúc
+ max_new_tokens=100,
+ do_sample=True,
+ temperature=0.7
+)
+
+# In kết quả
+for prompt, response in zip(prompts, responses):
+ print(f"Prompt: {prompt}")
+ print(f"Response: {response[0]['generated_text']}\n")
+```
+
+## Tích hợp với Web Server
+
+Dưới đây là cách tích hợp pipeline vào một ứng dụng FastAPI:
+
+```python
+from fastapi import FastAPI, HTTPException
+from transformers import pipeline
+import uvicorn
+
+app = FastAPI()
+
+# Khởi tạo pipeline toàn cục
+generator = pipeline(
+ "text-generation",
+ model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+ device_map="auto"
+)
+
+@app.post("/generate")
+async def generate_text(prompt: str):
+ try:
+ if not prompt:
+ raise HTTPException(status_code=400, detail="No prompt provided")
+
+ response = generator(
+ prompt,
+ max_new_tokens=100,
+ do_sample=True,
+ temperature=0.7
+ )
+
+ return {"generated_text": response[0]['generated_text']}
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+ uvicorn.run(app, host="0.0.0.0", port=5000)
+```
+
+## Hạn chế
+
+Mặc dù pipelines rất hữu ích cho việc tạo mẫu và triển khai quy mô nhỏ, chúng có một số hạn chế:
+
+- Các tùy chọn tối ưu hóa hạn chế so với các giải pháp phục vụ chuyên dụng
+- Không hỗ trợ các tính năng nâng cao như batching động
+- Có thể không phù hợp cho các khối lượng công việc sản xuất yêu cầu tốc độ cao
+
+Đối với các triển khai sản xuất với yêu cầu throughput cao, bạn có thể xem xét sử dụng Suy luận Sinh văn Bằng Văn bản (TGI) hoặc các giải pháp phục vụ chuyên biệt khác.
+
+## Tài nguyên
+
+- [Hướng dẫn Pipeline Hugging Face.](https://huggingface.co/docs/transformers/en/pipeline_tutorial)
+- [Tham khảo API Pipeline.](https://huggingface.co/docs/transformers/en/main_classes/pipelines)
+- [Tham số Sinh văn bản.](https://huggingface.co/docs/transformers/en/main_classes/text_generation)
+- [Hướng dẫn Quantization mô hình.](https://huggingface.co/docs/transformers/en/perf_infer_gpu_one)
\ No newline at end of file
diff --git a/vi/7_inference/text_generation_inference.md b/vi/7_inference/text_generation_inference.md
new file mode 100644
index 00000000..66843dd6
--- /dev/null
+++ b/vi/7_inference/text_generation_inference.md
@@ -0,0 +1,135 @@
+# Suy luận Sinh Văn Bằng Văn bản (TGI)
+
+Suy luận Sinh Văn Bằng Văn bản (TGI) là một bộ công cụ được phát triển bởi Hugging Face để triển khai và phục vụ các Mô hình Ngôn ngữ Lớn (LLMs). TGI được thiết kế để tối ưu hóa hiệu suất sinh văn cho các mô hình LLM mã nguồn mở phổ biến. TGI đang được sử dụng trong sản xuất bởi Hugging Chat - Giao diện mã nguồn mở cho các mô hình truy cập mở.
+
+## Tại sao nên sử dụng Suy luận Sinh Văn Bằng Văn bản?
+
+Suy luận Sinh Văn Bằng Văn bản giải quyết các thách thức chính trong việc triển khai các mô hình ngôn ngữ lớn vào sản xuất. Trong khi nhiều framework xuất sắc trong việc phát triển mô hình, TGI tối ưu hóa cho việc triển khai sản xuất và mở rộng quy mô. Một số tính năng chính bao gồm:
+
+- **Tensor Parallelism**: TGI có thể phân chia các mô hình trên nhiều GPU thông qua tensor parallelism, điều này rất quan trọng để phục vụ các mô hình lớn một cách hiệu quả.
+- **Continuous Batching**: Hệ thống batching liên tục tối đa hóa việc sử dụng GPU bằng cách xử lý các yêu cầu một cách động, trong khi các tối ưu hóa như Flash Attention và Paged Attention giúp giảm đáng kể việc sử dụng bộ nhớ và tăng tốc độ.
+- **Token Streaming**: Các ứng dụng thời gian thực được hưởng lợi từ token streaming thông qua Server-Sent Events, cung cấp phản hồi với độ trễ tối thiểu.
+
+## Cách sử dụng Suy luận Sinh Văn Bằng Văn bản
+
+### Sử dụng Python cơ bản
+
+TGI sử dụng một API REST đơn giản nhưng mạnh mẽ, giúp dễ dàng tích hợp vào các ứng dụng của bạn.
+
+### Sử dụng REST API
+
+TGI cung cấp một API RESTful nhận các payload dưới dạng JSON. Điều này giúp API có thể truy cập từ bất kỳ ngôn ngữ lập trình hoặc công cụ nào có thể gửi yêu cầu HTTP. Dưới đây là ví dụ cơ bản sử dụng curl:
+
+```bash
+# Yêu cầu sinh văn bản cơ bản
+curl localhost:8080/v1/chat/completions \
+ -X POST \
+ -d '{
+ "model": "tgi",
+ "messages": [
+ {
+ "role": "system",
+ "content": "You are a helpful assistant."
+ },
+ {
+ "role": "user",
+ "content": "What is deep learning?"
+ }
+ ],
+ "stream": true,
+ "max_tokens": 20
+}' \
+ -H 'Content-Type: application/json'
+```
+
+### Sử dụng `huggingface_hub` Python Client
+
+Python client `huggingface_hub` giúp quản lý kết nối, định dạng yêu cầu và phân tích phản hồi. Đây là cách bắt đầu sử dụng:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(
+ base_url="http://localhost:8080/v1/",
+)
+
+output = client.chat.completions.create(
+ model="tgi",
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Count to 10"},
+ ],
+ stream=True,
+ max_tokens=1024,
+)
+
+for chunk in output:
+ print(chunk.choices[0].delta.content)
+```
+
+### Sử dụng OpenAI API
+
+Nhiều thư viện hỗ trợ API OpenAI, vì vậy bạn có thể sử dụng cùng một client để tương tác với TGI.
+
+```python
+from openai import OpenAI
+
+# Khởi tạo client và trỏ tới TGI
+client = OpenAI(
+ base_url="http://localhost:8080/v1/",
+ api_key="-"
+)
+
+chat_completion = client.chat.completions.create(
+ model="tgi",
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant." },
+ {"role": "user", "content": "What is deep learning?"}
+ ],
+ stream=True
+)
+
+# Duyệt qua và in stream
+for message in chat_completion:
+ print(message)
+```
+
+## Chuẩn bị Mô hình cho TGI
+
+Để phục vụ mô hình với TGI, hãy đảm bảo mô hình của bạn đáp ứng các yêu cầu sau:
+
+1. **Kiến trúc được hỗ trợ**: Xác minh mô hình của bạn có kiến trúc được hỗ trợ (Llama, BLOOM, T5, v.v.)
+
+2. **Định dạng mô hình**: Chuyển đổi trọng số mô hình sang định dạng safetensors để tải nhanh hơn:
+
+```python
+from safetensors.torch import save_file
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("your-model")
+state_dict = model.state_dict()
+save_file(state_dict, "model.safetensors")
+```
+
+3. **Quantization** (tùy chọn): Quantize mô hình của bạn để giảm việc sử dụng bộ nhớ:
+
+```python
+from transformers import BitsAndBytesConfig
+
+quantization_config = BitsAndBytesConfig(
+ load_in_4bit=True,
+ bnb_4bit_compute_dtype="float16"
+)
+
+model = AutoModelForCausalLM.from_pretrained(
+ "your-model",
+ quantization_config=quantization_config
+)
+```
+
+## Tài nguyên tham khảo
+
+- [Tài liệu Suy luận Sinh Văn Bằng Văn bản](https://huggingface.co/docs/text-generation-inference)
+- [Kho lưu trữ TGI trên GitHub](https://github.com/huggingface/text-generation-inference)
+- [Model Hub của Hugging Face](https://huggingface.co/models)
+- [Tham khảo API TGI](https://huggingface.co/docs/text-generation-inference/api_reference)
\ No newline at end of file
diff --git a/vi/8_agents/README.md b/vi/8_agents/README.md
new file mode 100644
index 00000000..7711b7c3
--- /dev/null
+++ b/vi/8_agents/README.md
@@ -0,0 +1,36 @@
+# Trợ lý AI
+
+Trợ lý AI là các hệ thống tự động có khả năng hiểu các yêu cầu của người dùng, phân tích chúng thành các bước và thực hiện các hành động để hoàn thành nhiệm vụ. Các trợ lý này kết hợp mô hình ngôn ngữ với công cụ và chức năng bên ngoài để tương tác với môi trường. Module này hướng dẫn cách xây dựng các trợ lý hiệu quả sử dụng thư viện [`smolagents`](https://github.com/huggingface/smolagents), cung cấp một framework nhẹ để tạo ra các trợ lý AI có khả năng.
+
+## Tổng quan về Module
+
+Việc xây dựng các trợ lý hiệu quả đòi hỏi phải hiểu ba thành phần chính. Đầu tiên, khả năng truy xuất cho phép trợ lý truy cập và sử dụng thông tin từ nhiều nguồn khác nhau. Thứ hai, gọi chức năng cho phép trợ lý thực hiện các hành động cụ thể trong môi trường của nó. Cuối cùng, kiến thức chuyên ngành và các công cụ trang bị cho trợ lý các tác vụ chuyên biệt như thao tác mã nguồn.
+
+## Nội dung
+
+### 1️⃣ [Trợ lý Truy xuất](./retrieval_agents.md)
+
+Trợ lý truy xuất kết hợp các mô hình với các cơ sở kiến thức. Những trợ lý này có thể tìm kiếm và tổng hợp thông tin từ nhiều nguồn, tận dụng các kho lưu trữ vector để truy xuất hiệu quả và triển khai các mẫu RAG (Retrieval Augmented Generation). Chúng rất giỏi trong việc kết hợp tìm kiếm web với cơ sở kiến thức tùy chỉnh, đồng thời duy trì bối cảnh cuộc trò chuyện thông qua các hệ thống bộ nhớ. Module này bao gồm các chiến lược triển khai, bao gồm các cơ chế dự phòng để truy xuất thông tin đáng tin cậy.
+
+### 2️⃣ [Trợ lý Mã nguồn](./code_agents.md)
+
+Trợ lý mã nguồn là các hệ thống tự động chuyên biệt được thiết kế cho các tác vụ phát triển phần mềm. Những trợ lý này xuất sắc trong việc phân tích và sinh mã nguồn, thực hiện tái cấu trúc tự động và tích hợp với các công cụ phát triển. Module này cung cấp các thực hành tốt nhất để xây dựng các trợ lý tập trung vào mã nguồn có thể hiểu ngôn ngữ lập trình, làm việc với hệ thống xây dựng và tương tác với quản lý phiên bản trong khi duy trì các tiêu chuẩn chất lượng mã cao.
+
+### 3️⃣ [Chức năng Tùy chỉnh](./custom_functions.md)
+
+Trợ lý chức năng tùy chỉnh mở rộng các khả năng AI cơ bản thông qua các lời gọi chức năng chuyên biệt. Module này khám phá cách thiết kế các giao diện chức năng mô-đun và có thể mở rộng để tích hợp trực tiếp với logic ứng dụng của bạn. Bạn sẽ học cách triển khai xác thực và xử lý lỗi thích hợp trong khi tạo ra các quy trình làm việc dựa trên chức năng đáng tin cậy. Mục tiêu là xây dựng các hệ thống đơn giản, nơi các trợ lý có thể tương tác một cách dự đoán với các công cụ và dịch vụ bên ngoài.
+
+### Sổ tay Bài tập
+
+| Tiêu đề | Mô tả | Bài tập | Liên kết | Colab |
+|---------|-------|---------|---------|-------|
+| Xây dựng Trợ lý Nghiên cứu | Tạo một trợ lý có thể thực hiện các nhiệm vụ nghiên cứu sử dụng truy xuất và chức năng tùy chỉnh | 🐢 Xây dựng một trợ lý RAG đơn giản
🐕 Thêm các chức năng tìm kiếm tùy chỉnh
🦁 Tạo trợ lý nghiên cứu đầy đủ | [Sổ tay](./notebooks/agents.ipynb) | 
|
+
+## Tài nguyên
+
+- [Tài liệu smolagents](https://huggingface.co/docs/smolagents) - Tài liệu chính thức cho thư viện smolagents.
+- [Xây dựng Trợ lý Hiệu quả](https://www.anthropic.com/research/building-effective-agents) - Bài nghiên cứu về kiến trúc trợ lý.
+- [Hướng dẫn Trợ lý](https://huggingface.co/docs/smolagents/tutorials/building_good_agents) - Các thực hành tốt nhất để xây dựng các trợ lý đáng tin cậy.
+- [Trợ lý LangChain](https://python.langchain.com/docs/how_to/#agents) - Các ví dụ bổ sung về triển khai trợ lý.
+- [Hướng dẫn Gọi Chức năng](https://platform.openai.com/docs/guides/function-calling) - Hiểu rõ về gọi chức năng trong LLM.
+- [Thực hành RAG Tốt nhất](https://www.pinecone.io/learn/retrieval-augmented-generation/) - Hướng dẫn triển khai RAG hiệu quả.
\ No newline at end of file
diff --git a/vi/8_agents/code_agents.md b/vi/8_agents/code_agents.md
new file mode 100644
index 00000000..bcf3b3de
--- /dev/null
+++ b/vi/8_agents/code_agents.md
@@ -0,0 +1,67 @@
+# Trợ lý Mã (Code Agents)
+
+Trợ lý mã là các hệ thống tự động chuyên biệt có nhiệm vụ xử lý các tác vụ lập trình như phân tích, sinh mã, tái cấu trúc và kiểm thử. Những Trợ lý này tận dụng kiến thức chuyên ngành về các ngôn ngữ lập trình, hệ thống xây dựng và quản lý phiên bản để nâng cao quy trình phát triển phần mềm.
+
+## Tại sao lại dùng Trợ lý Mã?
+
+Trợ lý mã tăng tốc quá trình phát triển bằng cách tự động hóa các tác vụ lặp đi lặp lại trong khi vẫn duy trì chất lượng mã. Chúng xuất sắc trong việc sinh mã mẫu, thực hiện tái cấu trúc có hệ thống và nhận diện các vấn đề tiềm ẩn thông qua phân tích tĩnh. Các trợ lý kết hợp khả năng truy xuất để truy cập tài liệu và kho mã ngoài với việc gọi hàm để thực hiện các hành động cụ thể như tạo tệp hoặc chạy kiểm thử.
+
+## Các thành phần cơ bản của Trợ lý Mã
+
+Trợ lý mã được xây dựng trên các mô hình ngôn ngữ chuyên biệt được tinh chỉnh để hiểu mã. Những mô hình này được bổ sung với các công cụ phát triển như linters, formatters và compilers để tương tác với các môi trường thực tế. Thông qua các kỹ thuật truy xuất, các trợ lý duy trì nhận thức bối cảnh bằng cách truy cập tài liệu và lịch sử mã để phù hợp với các mô hình và tiêu chuẩn của tổ chức. Các hàm có mục đích hành động cho phép trợ lý thực hiện các tác vụ cụ thể như cam kết thay đổi hoặc khởi tạo yêu cầu gộp.
+
+Trong ví dụ sau, chúng ta tạo một trợ lý mã có thể tìm kiếm web sử dụng DuckDuckGo, giống như trợ lý truy xuất mà chúng ta đã xây dựng trước đó.
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel
+
+agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
+
+agent.run("How many seconds would it take for a leopard at full speed to run through Pont des Arts?")
+```
+
+Trong ví dụ tiếp theo, chúng ta tạo một trợ lý mã có thể lấy thời gian di chuyển giữa hai địa điểm. Ở đây, chúng ta sử dụng decorator `@tool` để định nghĩa một hàm tùy chỉnh có thể được sử dụng như một công cụ.
+
+```python
+from smolagents import CodeAgent, HfApiModel, tool
+
+@tool
+def get_travel_duration(start_location: str, destination_location: str, departure_time: Optional[int] = None) -> str:
+ """Gets the travel time in car between two places.
+
+ Args:
+ start_location: the place from which you start your ride
+ destination_location: the place of arrival
+ departure_time: the departure time, provide only a `datetime.datetime` if you want to specify this
+ """
+ import googlemaps # All imports are placed within the function, to allow for sharing to Hub.
+ import os
+
+ gmaps = googlemaps.Client(os.getenv("GMAPS_API_KEY"))
+
+ if departure_time is None:
+ from datetime import datetime
+ departure_time = datetime(2025, 1, 6, 11, 0)
+
+ directions_result = gmaps.directions(
+ start_location,
+ destination_location,
+ mode="transit",
+ departure_time=departure_time
+ )
+ return directions_result[0]["legs"][0]["duration"]["text"]
+
+agent = CodeAgent(tools=[get_travel_duration], model=HfApiModel(), additional_authorized_imports=["datetime"])
+
+agent.run("Can you give me a nice one-day trip around Paris with a few locations and the times? Could be in the city or outside, but should fit in one day. I'm travelling only via public transportation.")
+```
+
+Những ví dụ trên chỉ là sự khởi đầu của những gì bạn có thể làm với trợ lý mã. Bạn có thể tìm hiểu thêm về cách xây dựng trợ lý mã trong [tài liệu smolagents](https://huggingface.co/docs/smolagents).
+
+smolagents cung cấp một framework nhẹ để xây dựng các trợ lý mã, với triển khai lõi khoảng 1.000 dòng mã. Framework này chuyên về các trợ lý viết và thực thi các đoạn mã Python, cung cấp môi trường thực thi cách ly để đảm bảo an ninh. Nó hỗ trợ cả mô hình ngôn ngữ mã nguồn mở và bản quyền, giúp linh hoạt trong các môi trường phát triển khác nhau.
+
+## Đọc thêm
+
+- [Blog về smolagents](https://huggingface.co/blog/smolagents) - Giới thiệu về smolagents và các tương tác với mã nguồn.
+- [smolagents: Xây dựng Trợ lý Tốt](https://huggingface.co/docs/smolagents/tutorials/building_good_agents) - Các thực hành tốt nhất cho các trợ lý đáng tin cậy.
+- [Xây dựng Trợ lý Hiệu quả - Anthropic](https://www.anthropic.com/research/building-effective-agents) - Nguyên lý thiết kế trợ lý.
\ No newline at end of file
diff --git a/vi/8_agents/custom_functions.md b/vi/8_agents/custom_functions.md
new file mode 100644
index 00000000..fb49c070
--- /dev/null
+++ b/vi/8_agents/custom_functions.md
@@ -0,0 +1,69 @@
+# Trợ lý Chức năng Tùy chỉnh
+
+Trợ lý Chức năng Tùy chỉnh là các trợ lý AI sử dụng các lời gọi chức năng chuyên biệt (hay còn gọi là “công cụ”) để thực hiện các tác vụ. Khác với các trợ lý đa năng, Trợ lý Chức năng Tùy chỉnh tập trung vào việc thúc đẩy các quy trình công việc nâng cao bằng cách tích hợp trực tiếp với logic của ứng dụng của bạn. Ví dụ, bạn có thể cung cấp các truy vấn cơ sở dữ liệu, lệnh hệ thống, hoặc bất kỳ tiện ích tùy chỉnh nào dưới dạng các chức năng riêng biệt để trợ lý có thể gọi sử dụng.
+
+## Tại sao lại sử dụng Trợ lý Chức năng Tùy chỉnh?
+
+- **Mô-đun và Mở rộng**: Thay vì xây dựng một trợ lý đơn thể, bạn có thể thiết kế các chức năng riêng biệt đại diện cho các khả năng cụ thể, giúp kiến trúc của bạn dễ mở rộng hơn.
+- **Kiểm soát Chi tiết**: Các nhà phát triển có thể kiểm soát chính xác hành động của trợ lý bằng cách chỉ định chính xác các chức năng có sẵn và các tham số mà chúng chấp nhận.
+- **Tăng cường Độ tin cậy**: Bằng cách cấu trúc mỗi chức năng với các sơ đồ và xác thực rõ ràng, bạn giảm thiểu lỗi và hành vi không mong muốn.
+
+## Quy trình cơ bản
+
+1. **Xác định Chức năng**
+ Xác định các tác vụ có thể chuyển thành các chức năng tùy chỉnh (ví dụ: I/O tệp, truy vấn cơ sở dữ liệu, xử lý dữ liệu theo dòng).
+
+2. **Định nghĩa Giao diện**
+ Sử dụng chữ ký hàm hoặc sơ đồ để xác định rõ ràng các đầu vào, đầu ra và hành vi kỳ vọng của mỗi chức năng. Điều này tạo ra các hợp đồng rõ ràng giữa trợ lý và môi trường của nó.
+
+3. **Đăng ký với Trợ lý**
+ Trợ lý của bạn cần “học” các chức năng có sẵn. Thông thường, bạn sẽ truyền metadata mô tả giao diện của từng chức năng cho mô hình ngôn ngữ hoặc framework trợ lý.
+
+4. **Gọi và Xác thực**
+ Sau khi trợ lý chọn một chức năng để gọi, hãy chạy chức năng với các tham số đã cung cấp và xác thực kết quả. Nếu hợp lệ, trả kết quả lại cho trợ lý để làm bối cảnh, giúp nó đưa ra các quyết định tiếp theo.
+
+## Ví dụ
+
+Dưới đây là một ví dụ đơn giản minh họa cách các lời gọi chức năng tùy chỉnh có thể trông như thế nào trong mã giả. Mục tiêu là thực hiện tìm kiếm do người dùng xác định và lấy nội dung liên quan:
+
+```python
+# Định nghĩa một chức năng tùy chỉnh với các loại đầu vào/đầu ra rõ ràng
+def search_database(query: str) -> list:
+ """
+ Tìm kiếm trong cơ sở dữ liệu các bài viết khớp với truy vấn.
+
+ Args:
+ query (str): Chuỗi truy vấn tìm kiếm
+
+ Returns:
+ list: Danh sách các bài viết khớp với truy vấn
+ """
+ try:
+ results = database.search(query)
+ return results
+ except DatabaseError as e:
+ logging.error(f"Tìm kiếm cơ sở dữ liệu thất bại: {e}")
+ return []
+
+# Đăng ký chức năng với trợ lý
+agent.register_function(
+ name="search_database",
+ function=search_database,
+ description="Tìm kiếm cơ sở dữ liệu các bài viết khớp với truy vấn"
+)
+
+# Ví dụ sử dụng
+def process_search():
+ query = "Tìm bài viết gần đây về AI"
+ results = agent.invoke("search_database", query)
+
+ if results:
+ agent.process_results(results)
+ else:
+ logging.info("Không có kết quả nào cho truy vấn")
+```
+
+## Đọc thêm
+
+- [Blog về smolagents](https://huggingface.co/blog/smolagents) - Tìm hiểu về những tiến bộ mới nhất trong các trợ lý AI và cách chúng có thể được áp dụng vào các trợ lý chức năng tùy chỉnh.
+- [Xây dựng Trợ lý Tốt](https://huggingface.co/docs/smolagents/tutorials/building_good_agents) - Hướng dẫn toàn diện về các thực hành tốt nhất để phát triển các trợ lý chức năng tùy chỉnh đáng tin cậy và hiệu quả.
\ No newline at end of file
diff --git a/vi/8_agents/notebooks/agents.ipynb b/vi/8_agents/notebooks/agents.ipynb
new file mode 100644
index 00000000..d5a07fe1
--- /dev/null
+++ b/vi/8_agents/notebooks/agents.ipynb
@@ -0,0 +1,197 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Xây dựng Trợ lý AI\n",
+ "\n",
+ "Sổ tay này chứa các bài tập giúp bạn học cách xây dựng các loại trợ lý khác nhau sử dụng thư viện `smolagents`. Chúng ta sẽ bắt đầu từ các triển khai cơ bản đến các triển khai phức tạp hơn.\n",
+ "\n",
+ "## Cài đặt\n",
+ "\n",
+ "Đầu tiên, hãy cài đặt các gói cần thiết:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!pip install smolagents\n",
+ "\n",
+ "# Cài đặt các yêu cầu trong Google Colab\n",
+ "\n",
+ "# !pip install transformers datasets trl huggingface_hub\n",
+ "\n",
+ "# Authenticate to Hugging Face\n",
+ "from huggingface_hub import login\n",
+ "\n",
+ "login()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 🐢 Bài tập 1: Trợ lý Mã Cơ bản\n",
+ "\n",
+ "Hãy bắt đầu bằng cách tạo một trợ lý mã đơn giản có thể trả lời các câu hỏi liên quan đến lập trình bằng cách sử dụng tìm kiếm trên web."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel\n",
+ "\n",
+ "# Initialize the agent\n",
+ "agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())\n",
+ "\n",
+ "# Test the agent\n",
+ "response = agent.run(\"What's the difference between a list and a tuple in Python?\")\n",
+ "print(response)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 🤔 Thử thách Bài tập 1\n",
+ "Hãy thử yêu cầu trợ lý giải thích các khái niệm lập trình khác nhau và đánh giá các phản hồi của nó. Nó xử lý tốt như thế nào với:\n",
+ "1. Các câu hỏi về cú pháp cơ bản\n",
+ "2. Các tính năng đặc thù của ngôn ngữ\n",
+ "3. Các ví dụ mã nguồn"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 🐕 Bài tập 2: Trợ lý với Chức năng Tùy chỉnh\n",
+ "\n",
+ "Bây giờ, hãy tạo một trợ lý có thể thực hiện các tác vụ cụ thể bằng cách sử dụng các chức năng tùy chỉnh. Chúng ta sẽ triển khai một công cụ máy tính đơn giản."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from smolagents import CodeAgent, tool\n",
+ "from typing import Union\n",
+ "\n",
+ "\n",
+ "@tool\n",
+ "def calculate(operation: str, numbers: object) -> float:\n",
+ " \"\"\"Thực hiện các phép toán cơ bản trên một danh sách các số.\n",
+ "\n",
+ " Args:\n",
+ " operation: Một trong các phép toán 'sum', 'average', 'multiply', 'min', 'max'\n",
+ " numbers: Danh sách các số để thực hiện phép toán\n",
+ "\n",
+ " Returns:\n",
+ " float: Kết quả của phép toán\n",
+ " \"\"\"\n",
+ " if operation == \"sum\":\n",
+ " return sum(numbers)\n",
+ " elif operation == \"average\":\n",
+ " return sum(numbers) / len(numbers)\n",
+ " elif operation == \"multiply\":\n",
+ " result = 1\n",
+ " for n in numbers:\n",
+ " result *= n\n",
+ " return result\n",
+ " elif operation == \"min\":\n",
+ " return min(numbers)\n",
+ " elif operation == \"max\":\n",
+ " return max(numbers)\n",
+ " else:\n",
+ " raise ValueError(f\"Phép toán không hợp lệ: {operation}\")\n",
+ "\n",
+ "\n",
+ "# Tạo trợ lý với công cụ tùy chỉnh\n",
+ "math_agent = CodeAgent(tools=[calculate], model=HfApiModel())\n",
+ "\n",
+ "# Kiểm tra trợ lý\n",
+ "response = math_agent.run(\"Giá trị trung bình của 10, 15, 20, 25 và 30 là bao nhiêu?\")\n",
+ "print(response)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 🤔 Thử thách Bài tập 2\n",
+ "1. Thêm các phép toán toán học khác vào công cụ máy tính.\n",
+ "2. Tạo một công cụ tùy chỉnh mới (ví dụ: xử lý chuỗi hoặc tính toán ngày tháng).\n",
+ "3. Kết hợp nhiều công cụ tùy chỉnh trong một trợ lý."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 🦁 Bài tập 3: Trợ lý Truy xuất Nâng cao\n",
+ "\n",
+ "Cuối cùng, hãy xây dựng một trợ lý phức tạp hơn kết hợp tìm kiếm trên web với bộ nhớ để duy trì bối cảnh trong suốt các cuộc trò chuyện."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from smolagents import CodeAgent, DuckDuckGoSearchTool\n",
+ "\n",
+ "# Khởi tạo trợ lý với bộ nhớ\n",
+ "research_agent = CodeAgent(...) # TODO: Định nghĩa trợ lý\n",
+ "\n",
+ "# Kiểm tra với một cuộc trò chuyện nhiều lượt\n",
+ "questions = [\n",
+ " \"Các loại học máy chính là gì?\",\n",
+ " \"Bạn có thể giải thích học có giám sát chi tiết hơn không?\",\n",
+ " \"Một số thuật toán phổ biến cho loại này là gì?\",\n",
+ "]\n",
+ "\n",
+ "# TODO: Kiểm tra trợ lý"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 🤔 Thử thách Bài tập 3\n",
+ "1. Kiểm tra xem trợ lý duy trì bối cảnh như thế nào giữa các chủ đề khác nhau.\n",
+ "2. Triển khai công cụ cơ sở kiến thức tùy chỉnh (như ví dụ trong retrieval_agents.md).\n",
+ "3. Tạo một trợ lý kết hợp giữa khả năng hiểu mã và khả năng nghiên cứu."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/vi/8_agents/retrieval_agents.md b/vi/8_agents/retrieval_agents.md
new file mode 100644
index 00000000..1ff93616
--- /dev/null
+++ b/vi/8_agents/retrieval_agents.md
@@ -0,0 +1,121 @@
+# Xây dựng Hệ thống Trợ lý RAG
+
+Trợ lý RAG (Retrieval Augmented Generation) kết hợp sức mạnh của các trợ lý tự động với khả năng truy xuất kiến thức. Trong khi các hệ thống RAG truyền thống chỉ sử dụng một Mô hình Ngôn ngữ Lớn (LLM) để trả lời các truy vấn dựa trên thông tin đã truy xuất, trợ lý RAG nâng cao điều này bằng cách cho phép hệ thống tự động điều khiển quá trình truy xuất và phản hồi của chính nó một cách thông minh.
+
+RAG truyền thống có những hạn chế quan trọng - nó chỉ thực hiện một bước truy xuất đơn lẻ và dựa vào sự tương đồng ngữ nghĩa trực tiếp với truy vấn người dùng, điều này có thể bỏ lỡ thông tin liên quan. Trợ lý RAG giải quyết những thách thức này bằng cách trao quyền cho trợ lý để xây dựng các truy vấn tìm kiếm của riêng mình, đánh giá kết quả và thực hiện nhiều bước truy xuất khi cần thiết.
+
+## Truy xuất cơ bản với DuckDuckGo
+
+Chúng ta bắt đầu bằng việc xây dựng một trợ lý đơn giản có thể tìm kiếm web sử dụng DuckDuckGo. Trợ lý này sẽ có khả năng trả lời các câu hỏi bằng cách truy xuất thông tin liên quan và tổng hợp các phản hồi.
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel
+
+# Khởi tạo công cụ tìm kiếm
+search_tool = DuckDuckGoSearchTool()
+
+# Khởi tạo mô hình
+model = HfApiModel()
+
+agent = CodeAgent(
+ model = model,
+ tools=[search_tool]
+)
+
+# Ví dụ sử dụng
+response = agent.run(
+ "What are the latest developments in fusion energy?"
+)
+print(response)
+```
+
+Trợ lý sẽ:
+1. Phân tích truy vấn để xác định thông tin cần thiết
+2. Sử dụng DuckDuckGo để tìm kiếm nội dung liên quan
+3. Tổng hợp thông tin đã truy xuất thành một phản hồi mạch lạc
+4. Lưu trữ tương tác trong bộ nhớ để tham chiếu trong tương lai
+
+## Công cụ Cơ sở Kiến thức Tùy chỉnh
+
+Đối với các ứng dụng chuyên ngành, chúng ta thường muốn kết hợp tìm kiếm web với cơ sở kiến thức của riêng mình. Hãy tạo một công cụ tùy chỉnh có thể truy vấn cơ sở dữ liệu vector của tài liệu kỹ thuật.
+
+```python
+from smolagents import Tool
+
+class RetrieverTool(Tool):
+ name = "retriever"
+ description = "Sử dụng tìm kiếm ngữ nghĩa để truy xuất các phần tài liệu transformers có thể liên quan nhất để trả lời truy vấn của bạn."
+ inputs = {
+ "query": {
+ "type": "string",
+ "description": "Truy vấn để thực hiện. Truy vấn này nên gần về ngữ nghĩa với các tài liệu mục tiêu. Sử dụng dạng khẳng định thay vì câu hỏi.",
+ }
+ }
+ output_type = "string"
+
+ def __init__(self, docs, **kwargs):
+ super().__init__(**kwargs)
+ self.retriever = BM25Retriever.from_documents(
+ docs, k=10
+ )
+
+ def forward(self, query: str) -> str:
+ assert isinstance(query, str), "Truy vấn tìm kiếm của bạn phải là chuỗi"
+
+ docs = self.retriever.invoke(
+ query,
+ )
+ return "\nTài liệu truy xuất:\n" + "".join(
+ [
+ f"\n\n===== Tài liệu {str(i)} =====\n" + doc.page_content
+ for i, doc in enumerate(docs)
+ ]
+ )
+
+retriever_tool = RetrieverTool(docs_processed)
+```
+
+Trợ lý nâng cao này có thể:
+1. Kiểm tra tài liệu để tìm thông tin liên quan trước
+2. Tìm kiếm web nếu cần
+3. Kết hợp thông tin từ cả hai nguồn
+4. Duy trì bối cảnh cuộc trò chuyện thông qua bộ nhớ
+
+## Nâng cao Khả năng Truy xuất
+
+Khi xây dựng các hệ thống Trợ lý RAG, trợ lý có thể sử dụng các chiến lược phức tạp như:
+
+1. **Cải thiện Truy vấn** - Thay vì sử dụng truy vấn người dùng ban đầu, trợ lý có thể tạo ra các thuật ngữ tìm kiếm tối ưu hơn, phù hợp hơn với các tài liệu mục tiêu.
+2. **Truy xuất Đa bước** - Trợ lý có thể thực hiện nhiều tìm kiếm, sử dụng kết quả ban đầu để cải thiện các truy vấn tiếp theo.
+3. **Tích hợp Nguồn** - Thông tin có thể được kết hợp từ nhiều nguồn như tìm kiếm web và tài liệu nội bộ.
+4. **Xác thực Kết quả** - Nội dung truy xuất có thể được phân tích để xác định sự phù hợp và chính xác trước khi được đưa vào phản hồi.
+
+Các hệ thống Trợ lý RAG hiệu quả đòi hỏi phải xem xét cẩn thận nhiều yếu tố quan trọng. Trợ lý nên lựa chọn công cụ phù hợp dựa trên loại truy vấn và bối cảnh. Các hệ thống bộ nhớ giúp duy trì lịch sử cuộc trò chuyện và tránh các truy xuất lặp lại. Các chiến lược dự phòng giúp đảm bảo hệ thống vẫn có thể cung cấp giá trị ngay cả khi các phương pháp truy xuất chính không thành công. Thêm vào đó, việc triển khai các bước xác thực giúp đảm bảo độ chính xác và sự phù hợp của thông tin truy xuất.
+
+```python
+import datasets
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.retrievers import BM25Retriever
+
+knowledge_base = datasets.load_dataset("m-ric/huggingface_doc", split="train")
+knowledge_base = knowledge_base.filter(lambda row: row["source"].startswith("huggingface/transformers"))
+
+source_docs = [
+ Document(page_content=doc["text"], metadata={"source": doc["source"].split("/")[1]})
+ for doc in knowledge_base
+]
+
+text_splitter = RecursiveCharacterTextSplitter(
+ chunk_size=500,
+ chunk_overlap=50,
+ add_start_index=True,
+ strip_whitespace=True,
+ separators=["\n\n", "\n", ".", " ", ""],
+)
+docs_processed = text_splitter.split_documents(source_docs)
+```
+
+## Các Bước Tiếp Theo
+
+⏩ Xem qua module [Code Agents](./code_agents.md) để học cách xây dựng các trợ lý có thể thao tác với mã nguồn.
\ No newline at end of file