Hoàn thành bài "Chương 9 – Bài 2: Capstone Project — Xây dựng và triển khai hệ thống lên VPS" trước để mở khoá bài này.Đến bài trước

Giới thiệu

Sau khi xây dựng xong một hệ thống AI Agent, bước tiếp theo không kém phần quan trọng là đảm bảo nó hoạt động đúng, ổn định, và không đốt tiền không cần thiết. Bài học này đi vào 4 trụ cột cuối cùng của vòng đời một dự án AI thực tế: kiểm thử toàn diện, thiết lập monitoring, tối ưu chi phí API, và lên kế hoạch mở rộng hệ thống khi người dùng tăng lên.

Đây là nội dung thường bị bỏ qua trong giai đoạn prototype nhưng lại quyết định sự sống còn của hệ thống khi đưa vào production.

Kiểm thử toàn diện hệ thống AI Agent

Kiểm thử hệ thống AI khác với kiểm thử phần mềm truyền thống ở chỗ: đầu ra của LLM không hoàn toàn deterministic. Vì vậy cần phân tầng kiểm thử.

Tầng 1 là unit test các công cụ (tools) mà agent sử dụng — đây là phần thuần logic, kiểm thử bình thường:

python
import pytest
from tools.calculator import calculate_discount
def test_calculate_discount_basic():
result = calculate_discount(price=100, percent=20)
assert result == 80.0
def test_calculate_discount_zero():
result = calculate_discount(price=100, percent=0)
assert result == 100.0

Tầng 2 là integration test luồng agent — kiểm tra xem agent có gọi đúng tool với đúng tham số không. Dùng mock để tránh tốn token thật:

python
from unittest.mock import patch, MagicMock
from agent.core import run_agent
@patch("agent.core.openai_client.chat.completions.create")
def test_agent_calls_correct_tool(mock_create):
mock_create.return_value = MagicMock(
choices=[MagicMock(message=MagicMock(
content=None,
tool_calls=[MagicMock(
function=MagicMock(
name="get_weather",
arguments='{"city": "Hanoi"}'
)
)]
))]
)
result = run_agent("Thời tiết Hà Nội hôm nay thế nào?")
assert "get_weather" in result["tool_used"]

Tầng 3 là eval test — đánh giá chất lượng câu trả lời theo bộ test case có sẵn. Dùng một LLM khác hoặc regex để chấm:

python
EVAL_CASES = [
{
"input": "Tổng 2 + 3 bằng mấy?",
"expected_contains": "5"
},
{
"input": "Thủ đô Việt Nam là gì?",
"expected_contains": "Hà Nội"
}
]
def run_eval(agent_fn):
passed = 0
for case in EVAL_CASES:
response = agent_fn(case["input"])
if case["expected_contains"].lower() in response.lower():
passed += 1
print(f"Eval score: {passed}/{len(EVAL_CASES)}")
sơ đồ 3 tầng kiểm thử AI Agent: Unit Test (tools) → Integration Test (agent flow) → Eval Test (output quality)

Thiết lập monitoring và logging

Một hệ thống AI production cần ghi lại đủ thông tin để debug khi có sự cố và theo dõi hiệu năng theo thời gian.

Cấu trúc log tối thiểu cần có: timestamp, session_id, input, output, model dùng, số token tiêu thụ, latency, và nếu có lỗi thì ghi rõ error type:

python
import time
import json
import logging
from datetime import datetime
logging.basicConfig(filename="agent.log", level=logging.INFO)
def log_interaction(session_id, user_input, response, usage, latency_ms):
entry = {
"timestamp": datetime.utcnow().isoformat(),
"session_id": session_id,
"input": user_input,
"output": response,
"tokens_prompt": usage.prompt_tokens,
"tokens_completion": usage.completion_tokens,
"latency_ms": latency_ms
}
logging.info(json.dumps(entry, ensure_ascii=False))

Với hệ thống lớn hơn, có thể đẩy log lên các dịch vụ như Langfuse, Weights & Biases, hoặc đơn giản là một bảng PostgreSQL để sau này query phân tích. Langfuse là lựa chọn phổ biến vì có SDK Python và hỗ trợ trace từng bước của agent:

python
from langfuse import Langfuse
langfuse = Langfuse(public_key="...", secret_key="...", host="https://cloud.langfuse.com")
trace = langfuse.trace(name="customer-support-agent", user_id=session_id)
span = trace.span(name="llm-call", input={"messages": messages})
# ... gọi OpenAI ...
span.end(output={"response": response_text})

Tối ưu chi phí API

Chi phí OpenAI API tỷ lệ trực tiếp với số token. Có 4 kỹ thuật chính để giảm chi phí mà không hy sinh chất lượng đáng kể.

Kỹ thuật 1: Rút gọn system prompt. Mỗi request đều gửi kèm system prompt — nếu prompt dài 500 token và bạn có 10.000 request/ngày, đó là 5 triệu token chỉ riêng system prompt. Viết ngắn gọn, loại bỏ ví dụ thừa.

Kỹ thuật 2: Cắt bớt conversation history. Chỉ giữ N tin nhắn gần nhất thay vì toàn bộ lịch sử:

python
MAX_HISTORY = 10
def trim_history(messages: list) -> list:
system_msgs = [m for m in messages if m["role"] == "system"]
non_system = [m for m in messages if m["role"] != "system"]
return system_msgs + non_system[-MAX_HISTORY:]

Kỹ thuật 3: Chọn đúng model theo task. Không phải task nào cũng cần GPT-4o. Phân loại request và route sang model rẻ hơn khi có thể:

python
def select_model(task_type: str) -> str:
if task_type in ["classification", "extraction", "simple_qa"]:
return "gpt-4o-mini" # rẻ hơn ~15 lần so với gpt-4o
return "gpt-4o"

Kỹ thuật 4: Caching kết quả với prompt giống nhau. Dùng Redis hoặc dict đơn giản để cache theo hash của prompt:

python
import hashlib
import redis
cache = redis.Redis(host="localhost", port=6379, decode_responses=True)
def cached_llm_call(prompt: str, model: str) -> str:
key = hashlib.md5(f"{model}:{prompt}".encode()).hexdigest()
cached = cache.get(key)
if cached:
return cached
response = call_openai(prompt, model)
cache.setex(key, 3600, response) # cache 1 giờ
return response
sơ đồ luồng quyết định tối ưu chi phí: Request đến → Kiểm tra cache → Phân loại task → Chọn model phù hợp → Gọi API → Lưu cache

Lên kế hoạch mở rộng hệ thống

Khi người dùng tăng lên, 3 điểm nghẽn thường gặp nhất là: rate limit của OpenAI API, độ trễ khi xử lý tuần tự, và chi phí tăng tuyến tính.

Để xử lý rate limit, dùng exponential backoff kết hợp queue:

python
import time
from openai import RateLimitError
def call_with_retry(client, messages, model, max_retries=3):
for attempt in range(max_retries):
try:
return client.chat.completions.create(
model=model,
messages=messages
)
except RateLimitError:
wait = 2 ** attempt # 1s, 2s, 4s
time.sleep(wait)
raise Exception("Max retries exceeded")

Để xử lý song song nhiều request, dùng asyncio với giới hạn concurrency:

python
import asyncio
from openai import AsyncOpenAI
async def process_batch(prompts: list, max_concurrent=5):
client = AsyncOpenAI()
semaphore = asyncio.Semaphore(max_concurrent)
async def process_one(prompt):
async with semaphore:
response = await client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
return await asyncio.gather(*[process_one(p) for p in prompts])

Về kiến trúc dài hạn, khi hệ thống phục vụ hàng nghìn người dùng đồng thời, nên tách agent logic thành microservice độc lập, dùng message queue (RabbitMQ hoặc Redis Queue) để nhận job bất đồng bộ, và horizontal scale bằng cách chạy nhiều worker instance. Điểm quan trọng là giữ stateless — mọi trạng thái conversation lưu vào DB ngoài, không lưu trong memory của worker.

Tổng kết

Bốn trụ cột của một hệ thống AI production bền vững là kiểm thử đúng tầng, logging đủ thông tin, tối ưu token thông minh, và kiến trúc sẵn sàng mở rộng. Không nhất thiết phải làm hết ngay từ đầu, nhưng nên biết rõ từng điểm để ưu tiên đúng khi hệ thống lớn dần. Prototype chỉ cần chạy được — production cần chạy ổn định, rẻ, và quan sát được.

Luyện tập sau buổi học

Bài kiểm tra cuối bài

Ôn lại kiến thức, thử sức và nhận góp ý cho bài làm.

0/1
Đã trả lời · 0/1