---
title: "Dùng LLM-as-a-judge chấm output AI: khi nào tin được, khi nào không"
description: "LLM-as-a-judge là gì: dùng model chấm output theo rubric rồi đối chiếu nhãn tay; demo 12 câu CSKH với gpt-6-astra, temperature 0, khớp 10/12 trên bộ minh họa."
canonical: "https://200lab.io/blog/llm-as-a-judge-la-gi"
published: "2026-11-17T02:00:18Z"
updated: "2026-11-17T02:00:18Z"
authors: ["Việt Trần"]
tags: ["AI"]
reading_minutes: 17
access: "public"
---

Giả sử team bạn vừa sửa prompt cho bot chăm sóc khách hàng, gõ thử vài câu thấy trả lời ổn rồi đẩy lên hệ thống. Hôm sau, bot tư vấn sai chính sách đổi trả hàng của shop.

**LLM-as-a-judge là kỹ thuật dùng một model ngôn ngữ lớn để chấm điểm đầu ra của hệ thống AI khác dựa trên bộ tiêu chí có sẵn.**

Cách kiểm tra thủ công vài câu rồi kết luận hệ thống chạy ổn được OpenAI gọi là vibe-based eval. Trong bài này, mình giải thích LLM-as-a-judge là gì, rồi chạy thử một bộ 12 câu hỏi minh họa với model thật.

## Vibe-based eval và cái giá của việc chỉ thử vài câu

Khi xây dựng các app hoặc service có tích hợp AI, đầu ra của model có thể thay đổi giữa các lần gọi khác nhau. Vì vậy, eval, tức quy trình đánh giá chất lượng đầu ra của hệ thống, đóng vai trò giữ nhịp cho cả quá trình phát triển.

Theo tài liệu [Evaluation best practices](https://developers.openai.com/api/docs/guides/evaluation-best-practices) của OpenAI, một anti-pattern rất phổ biến là vibe-based evals. Đây là kiểu đánh giá dựa trên cảm giác rằng hệ thống có vẻ đang chạy tốt, hoặc đợi đến khi đưa sản phẩm ra thực tế rồi mới bắt đầu kiểm tra.

Quay lại tình huống ở phần mở bài, việc bạn làm [prompt engineering](/blog/prompt-engineering-la-gi) hay chỉnh sửa [system prompt](/blog/system-prompt-la-gi) cho một nhóm câu hỏi này có thể làm hỏng cách bot trả lời ở nhóm câu hỏi khác. Nếu chỉ gõ thử vài câu theo cảm tính, những góc khuất trong chính sách đổi trả sẽ bị bỏ lọt cho đến khi khách hàng thật sự hỏi tới.

Để kiểm tra chất lượng một cách bài bản hơn khi số lượng kịch bản tăng lên, chúng ta không thể ngồi đọc bằng mắt từng câu mãi được. Lúc này, anh em sẽ cần đến một quy trình chấm điểm tự động hóa nhưng vẫn bám sát tiêu chí của con người.

## LLM-as-a-judge là gì

Hiểu một cách đơn giản, LLM-as-a-judge là kỹ thuật dùng một [model ngôn ngữ lớn](/blog/large-language-model-la-gi) để chấm điểm đầu ra của một hệ thống AI khác dựa trên bộ tiêu chí có sẵn. Theo OpenAI, nhóm kỹ thuật này còn được gọi là model graders, giúp tiết kiệm chi phí và dễ mở rộng quy mô hơn so với việc dùng người chấm thủ công từng câu.

Khi mới thiết lập quy trình này, theo OpenAI, bạn nên bắt đầu với một model mạnh như `gpt-6-astra` để đóng vai trò người chấm. Sau đó, chúng ta cần đo lường mức độ đồng thuận giữa điểm của máy và nhãn do con người gán, rồi mới tính đến chuyện tối ưu chi phí hoặc độ trễ.

Trong tài liệu của mình, OpenAI nêu ra ba kiểu chấm phổ biến cho LLM-as-a-judge. Kiểu thứ nhất là pairwise comparison, nơi model so sánh hai câu trả lời để chọn ra phương án tốt hơn. Kiểu thứ hai là single answer grading, tức chấm điểm trực tiếp một câu trả lời đơn lẻ. Kiểu thứ ba là reference-guided grading, dùng thêm một tài liệu hoặc câu trả lời chuẩn làm mốc tham chiếu khi chấm, gần với bối cảnh của các hệ thống [RAG](/blog/rag-la-gi), nơi câu trả lời cần bám tài liệu gốc.

Bản demo trong bài viết này của mình kết hợp giữa reference-guided grading và single answer grading. Cụ thể, mình cung cấp bản chính sách đổi trả chuẩn làm mốc tham chiếu, sau đó yêu cầu model chấm từng câu trả lời của bot theo hai mức đạt hoặc không đạt, gọi là pass/fail.

![Ba kiểu chấm phổ biến; demo trong bài chấm từng câu theo chính sách chuẩn](https://assets.200lab.io/sha256/b0/b024bbc25f925d9d93b07547883e310dd59fac52313e337bfcba47661c43970a/generations/4e823849ab1e6331264280d97a329460ce6833908a7c6ab404e8cc13c7449f38)

Theo OpenAI, chúng ta nên dùng pairwise comparison hoặc kết quả dạng pass/fail để việc đánh giá đạt độ tin cậy cao hơn. Tất nhiên, đây chỉ là một hướng tiếp cận phù hợp với bài toán kiểm tra tính tuân thủ chính sách, không phải là cách duy nhất cho mọi hệ thống.

## Rubric, nhãn tay và bộ 12 câu minh họa

Để model chấm được câu trả lời, bạn cần cung cấp cho nó một rubric, tức là bộ tiêu chí chấm điểm rõ ràng. Trong bài này, mình tự soạn một chính sách đổi trả gồm bảy điều khoản và một bộ 12 câu hỏi kèm câu trả lời của bot để làm dữ liệu minh họa.

Bảy điều minh họa gồm: đổi hoặc trả trong 30 ngày kể từ ngày nhận; hàng còn tem và chưa dùng; hàng final sale không đổi trả khi khách đổi ý; nếu shop gửi sai size hoặc sai mẫu thì vẫn đổi được, kể cả hàng final sale; tiền hoàn về đúng phương thức gốc trong 5-7 ngày làm việc sau khi kho nhận hàng; đổi size miễn phí một lần trong 30 ngày nếu còn hàng; phí vận chuyển do shop chịu nếu lỗi từ shop, do khách chịu nếu khách đổi ý.

Dựa trên bảy điều này, mình viết rubric cho judge với nguyên tắc pass khi câu trả lời đúng chính sách và không tự ý hứa hẹn thêm quyền lợi ngoài quy định. Ngược lại, câu trả lời sẽ bị chấm fail nếu sai mốc 30 ngày, bỏ qua điều kiện còn tem và chưa sử dụng, cho đổi hàng final sale khi khách đổi ý, hoàn tiền sang phương thức khác, hoặc gán sai bên chịu phí vận chuyển.

Đặc biệt, những câu trả lời đúng phần lõi chính sách nhưng tự bịa thêm cam kết mới, một dạng [ảo giác AI](/blog/ao-giac-ai-la-gi-vi-sao-ai-noi-sai), cũng sẽ bị tính là fail. Ví dụ ở câu Q11 trong bộ thử nghiệm, mình cố tình thiết kế cho bot trả lời đúng quy định gốc nhưng lại hứa thêm rằng khách sẽ được hoàn tiền trong 24 giờ và đổi hàng không giới hạn số lần, nhằm kiểm tra xem rubric có bắt được lỗi bịa thông tin hay không.

Toàn bộ nhãn pass/fail chuẩn trên 12 câu này đều là nhãn tay do một mình mình tự gắn khi soạn dataset minh họa, không phải kết quả thẩm định từ một hội đồng chuyên gia. Mình cũng sẽ không chép nguyên văn cả 12 câu hỏi vào bài để tránh làm loãng mạch đọc, mà chỉ lấy ra các ý chính khi phân tích kết quả.

## Chạy thử 12 câu với gpt-6-astra

Để kiểm tra xem lý thuyết trên hoạt động thế nào, mình đã viết một chương trình nhỏ bằng ngôn ngữ Go để đọc file dữ liệu và gọi API thật tới model `gpt-6-astra`. Trong lúc gọi model, mình đặt [tham số temperature](/blog/cac-thuat-ngu-llm-quan-trong), tức mức độ ngẫu nhiên của đầu ra, ở mức 0 để giảm bớt sự biến thiên giữa các lần tạo văn bản.

Chương trình thực hiện tuần tự 12 lời gọi tương ứng với 12 câu trong bộ minh họa, không in API key ra màn hình và 12/12 kết quả trả về đều được phân tích cú pháp thành công, không có lời gọi nào bị lỗi. Chúng ta thử xem đoạn code dưới đây nha:

```go
// compare_judge.go calls a real chat model as an LLM-as-a-judge.
// It compares judge pass/fail verdicts with hand labels on 12 illustrative
// customer-support answers. It does not invent scores: failed calls are
// recorded as errors.
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strings"
	"time"
)

type Case struct {
	ID       string `json:"id"`
	Question string `json:"question"`
	Bot      string `json:"bot"`
	Hand     string `json:"hand"`
}

type Dataset struct {
	PolicyName  string  `json:"policy_name"`
	Policy      string  `json:"policy"`
	Rubric      string  `json:"rubric"`
	Model       string  `json:"model"`
	Temperature float64 `json:"temperature"`
	Cases       []Case  `json:"cases"`
}

type chatReq struct {
	Model       string    `json:"model"`
	Temperature float64   `json:"temperature"`
	Messages    []message `json:"messages"`
}

type message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type chatResp struct {
	Model   string `json:"model"`
	Choices []struct {
		FinishReason string `json:"finish_reason"`
		Message      struct {
			Content string `json:"content"`
		} `json:"message"`
	} `json:"choices"`
}

func main() {
	raw, err := os.ReadFile("cases.json")
	if err != nil {
		log.Fatal(err)
	}
	var ds Dataset
	if err := json.Unmarshal(raw, &ds); err != nil {
		log.Fatal(err)
	}
	key := os.Getenv("KEY4U_API_KEY")
	if key == "" {
		log.Fatal("KEY4U_API_KEY is not set")
	}

	sys := "You are a strict grader for a shop return policy. Use only the policy and rubric in the user message. Reply with a single JSON object: {\"verdict\":\"pass\"} or {\"verdict\":\"fail\"}, plus a short \"reason\" in Vietnamese. No markdown, no extra text. verdict must be lowercase pass or fail."

	fmt.Println("LLM-as-a-judge demo")
	fmt.Println("model:", ds.Model)
	fmt.Println("temperature:", ds.Temperature)
	fmt.Println("cases:", len(ds.Cases))
	fmt.Println("labels: hand labels by the article author on this illustrative set")
	fmt.Println("endpoint: chat completions (OpenAI-compatible)")
	fmt.Println()

	agree, parsed, failed := 0, 0, 0
	client := &http.Client{Timeout: 120 * time.Second}

	for _, c := range ds.Cases {
		user := "CHINH SACH:\n" + ds.Policy + "\n\nRUBRIC:\n" + ds.Rubric +
			"\n\nCAU HOI CUA KHACH:\n" + c.Question +
			"\n\nCAU TRA LOI CUA BOT:\n" + c.Bot +
			"\n\nHay cham pass hoac fail."
		body, _ := json.Marshal(chatReq{
			Model:       ds.Model,
			Temperature: ds.Temperature,
			Messages:    []message{{Role: "system", Content: sys}, {Role: "user", Content: user}},
		})
		req, err := http.NewRequest(http.MethodPost, "https://api.key4u.vn/v1/chat/completions", bytes.NewReader(body))
		if err != nil {
			log.Fatal(err)
		}
		req.Header.Set("Content-Type", "application/json")
		req.Header.Set("Authorization", "Bearer "+key)

		t0 := time.Now()
		resp, err := client.Do(req)
		elapsed := time.Since(t0).Round(time.Millisecond)
		if err != nil {
			failed++
			fmt.Printf("%s  hand=%-4s  judge=ERROR  agree=?  err=%s  latency=%s\n", c.ID, c.Hand, err.Error(), elapsed)
			continue
		}
		rawResp, _ := io.ReadAll(resp.Body)
		resp.Body.Close()
		if resp.StatusCode != 200 {
			failed++
			fmt.Printf("%s  hand=%-4s  judge=ERROR  agree=?  http=%d  latency=%s\n", c.ID, c.Hand, resp.StatusCode, elapsed)
			continue
		}
		var cr chatResp
		if err := json.Unmarshal(rawResp, &cr); err != nil || len(cr.Choices) == 0 {
			failed++
			fmt.Printf("%s  hand=%-4s  judge=ERROR  agree=?  err=bad_response  latency=%s\n", c.ID, c.Hand, elapsed)
			continue
		}
		content := cr.Choices[0].Message.Content
		verdict, ok := parseVerdict(content)
		if !ok {
			failed++
			fmt.Printf("%s  hand=%-4s  judge=ERROR  agree=?  err=unparsed  latency=%s  raw=%q\n",
				c.ID, c.Hand, elapsed, trim(content, 120))
			continue
		}
		parsed++
		mark := "no"
		if verdict == c.Hand {
			agree++
			mark = "yes"
		}
		fmt.Printf("%s  hand=%-4s  judge=%-4s  agree=%s  latency=%s\n", c.ID, c.Hand, verdict, mark, elapsed)
	}

	fmt.Println()
	fmt.Printf("parsed: %d/%d\n", parsed, len(ds.Cases))
	fmt.Printf("failed calls or unparsed: %d\n", failed)
	if parsed > 0 {
		fmt.Printf("agreement with hand labels (parsed only): %d/%d\n", agree, parsed)
	} else {
		fmt.Println("agreement with hand labels: n/a (no parsed verdicts)")
	}
	fmt.Println("This is agreement on 12 illustrative items, not a production eval score.")
}

func parseVerdict(s string) (string, bool) {
	s = strings.TrimSpace(s)
	fence := strings.Repeat("`", 3)
	s = strings.TrimPrefix(s, fence+"json")
	s = strings.TrimPrefix(s, fence)
	s = strings.TrimSuffix(s, fence)
	s = strings.TrimSpace(s)
	var m struct {
		Verdict string `json:"verdict"`
	}
	if err := json.Unmarshal([]byte(s), &m); err != nil {
		// try to find a compact JSON object in the text
		i := strings.Index(s, "{")
		j := strings.LastIndex(s, "}")
		if i >= 0 && j > i {
			if err2 := json.Unmarshal([]byte(s[i:j+1]), &m); err2 != nil {
				return "", false
			}
		} else {
			return "", false
		}
	}
	v := strings.ToLower(strings.TrimSpace(m.Verdict))
	if v == "pass" || v == "fail" {
		return v, true
	}
	return "", false
}

func trim(s string, n int) string {
	s = strings.ReplaceAll(s, "\n", " ")
	if len(s) <= n {
		return s
	}
	return s[:n] + "..."
}
```

```text
LLM-as-a-judge demo
model: gpt-6-astra
temperature: 0
cases: 12
labels: hand labels by the article author on this illustrative set
endpoint: chat completions (OpenAI-compatible)

Q1  hand=pass  judge=pass  agree=yes  latency=4.605s
Q2  hand=fail  judge=fail  agree=yes  latency=3.675s
Q3  hand=pass  judge=pass  agree=yes  latency=3.107s
Q4  hand=pass  judge=fail  agree=no  latency=3.068s
Q5  hand=fail  judge=fail  agree=yes  latency=10.369s
Q6  hand=fail  judge=fail  agree=yes  latency=15.899s
Q7  hand=fail  judge=fail  agree=yes  latency=4.41s
Q8  hand=pass  judge=pass  agree=yes  latency=3.737s
Q9  hand=fail  judge=fail  agree=yes  latency=3.806s
Q10  hand=pass  judge=fail  agree=no  latency=4.598s
Q11  hand=fail  judge=fail  agree=yes  latency=4.589s
Q12  hand=pass  judge=pass  agree=yes  latency=3.276s

parsed: 12/12
failed calls or unparsed: 0
agreement with hand labels (parsed only): 10/12
This is agreement on 12 illustrative items, not a production eval score.
```

Bạn có thể bấm nút Tới ở khung dưới đây để đi qua từng bước, xem judge chấm pass/fail theo rubric trên cả 12 câu rồi đối chiếu với nhãn tay của mình, từ lỗi bịa cam kết ở Q11 mà judge bắt được đến hai câu lệch ở Q4 và Q10.

Nhìn vào kết quả chạy thực tế trên bộ minh họa này, tỷ lệ đồng thuận giữa judge và nhãn tay của mình đạt mức 10/12. Cụ thể, model `gpt-6-astra` đã chấm khớp với nhãn tay ở 10 câu bao gồm Q1, Q2, Q3, Q5, Q6, Q7, Q8, Q9, Q11 và Q12. Ngay cả trường hợp câu Q11 có gài lỗi bot bịa thêm cam kết mà mình nhắc ở phần trước, judge cũng chấm là fail, khớp với nhãn tay.

Tuy nhiên, có hai trường hợp bị lệch giữa máy và người là câu Q4 và câu Q10. Ở câu Q4, khách hỏi về việc đổi size và bot trả lời khách được đổi miễn phí một lần trong 30 ngày nếu còn hàng, khớp với điều sáu nên nhãn tay của mình là pass, nhưng judge lại chấm là fail.

Tương tự ở câu Q10, tình huống đưa ra là hàng thuộc diện final sale nhưng do shop gửi nhầm size, bot đã cho phép khách đổi hàng theo đúng ngoại lệ ở điều bốn. Nhãn tay mình gán cho câu Q10 này là pass, nhưng kết quả từ judge trả về vẫn là fail. Mình không đi sâu vào việc suy đoán lý do vì sao model lại đánh trượt hai câu này, nhưng sự chênh lệch này là dữ kiện thực tế rất đáng chú ý.

Con số 10/12 ở đây chỉ phản ánh một lần chạy với temperature bằng 0 trên bộ 12 câu minh họa, không phải là điểm số đánh giá cho một hệ thống production. Bản thân tài liệu của OpenAI cũng nhấn mạnh rằng không có chiến lược nào là hoàn hảo, chất lượng của LLM-as-a-judge sẽ thay đổi tùy theo context bài toán, và chúng ta cần dùng phản hồi của con người để hiệu chỉnh lại hệ thống chấm tự động.

Trong lần chạy này, độ trễ từng lời gọi rơi vào khoảng 3 đến 16 giây; đây chỉ là dữ kiện ghi nhận, không lấy làm benchmark tốc độ của model.

![Trên bộ 12 câu minh họa, judge khớp nhãn tay 10 câu và lệch ở Q4 cùng Q10](https://assets.200lab.io/sha256/ef/ef8dba42e0610bd1efe9696fae959dba25e1be22853257ad16792b9d7f8f53f5/generations/472b939e2b0fd36a2b45250f83ec2a146d4b333574e10e6ccbe94538acf57b1b)

## Bias và giới hạn của LLM-as-a-judge

Việc `gpt-6-astra` vẫn chấm lệch hai câu trên bộ nhỏ này cho thấy kỹ thuật vẫn có giới hạn. Theo OpenAI, khi dùng LLM làm người chấm, bạn sẽ gặp các thiên kiến hệ thống gọi là bias, tiêu biểu là position bias và verbosity bias.

Position bias là hiện tượng model có xu hướng ưu ái câu trả lời nằm ở một vị trí cố định khi phải so sánh nhiều phương án với nhau. Trong khi đó, verbosity bias là việc model thường có thiện cảm và chấm điểm cao hơn cho những câu trả lời dài dòng, nhiều chữ, bất kể chất lượng thông tin bên trong như thế nào.

Trong phạm vi bản demo 12 câu của bài viết này, mình không thiết kế thí nghiệm để đo lường hai loại bias trên bằng con số cụ thể, mà chỉ nêu ra từ tài liệu của OpenAI để bạn cảnh giác. Chúng ta cũng không thể lấy kết quả chạy thử vừa rồi để kết luận rằng bản demo đã chứng minh hay giải quyết xong các vấn đề về bias.

Để giảm thiểu rủi ro từ những giới hạn này, theo OpenAI, bạn nên kiểm soát chặt độ dài của câu trả lời và viết một rubric thật chi tiết, rõ ràng. Ngoài ra, việc yêu cầu model thực hiện bước lập luận, tức reasoning, để giải thích lý do trước khi đưa ra quyết định chấm điểm cuối cùng cũng thường giúp chất lượng eval tốt hơn.

Chỉ khi nào quy trình chấm bằng model đạt được tốc độ nhanh, chi phí hợp lý và cho thấy sự đồng thuận ổn định với nhãn của con người thì chúng ta mới nên mở rộng quy mô áp dụng. Thêm một lưu ý nhỏ là bài viết này của mình chỉ tập trung vào kỹ thuật chấm điểm bằng model, không đi vào Evals platform của OpenAI vì công cụ này đang trong lộ trình ngừng hỗ trợ (chuyển sang chế độ chỉ đọc từ 31/10/2026 và dự kiến đóng vào 30/11/2026); nếu cần một nền tảng theo dõi và chạy eval, bạn có thể tham khảo [LangSmith](/blog/langsmith-la-gi).

## Sai lầm hay gặp khi dùng LLM-as-a-judge

Từ trải nghiệm chạy thử và các khuyến nghị kỹ thuật, mình thấy sai lầm đầu tiên mà nhiều team hay mắc phải vẫn là thói quen sửa prompt xong chỉ gõ thử vài câu, thấy xuôi tai rồi đưa thẳng lên môi trường thật. Khi chuyển sang dùng LLM-as-a-judge, một cái bẫy khác lại xuất hiện là bạn nhìn thấy điểm pass cao từ máy chấm đã vội mừng mà bỏ qua bước đối chiếu lại với nhãn tay của con người.

Nếu không đối chiếu nhãn người, những chỗ máy chấm sai như Q4 và Q10 sẽ bị bỏ qua. Rubric mơ hồ, hoặc để model tự suy diễn tiêu chí, cũng làm eval lệch hướng. Một lần chạy trên bộ 12 câu cũng không nên coi là benchmark cho mọi bot hay mọi bài toán.

Khi báo cáo hoặc theo dõi chất lượng hệ thống qua các phiên bản, cách làm thực tế là bạn hãy giữ một bộ eval cố định để làm mốc so sánh. Trong mỗi lần chạy eval, hãy ghi chép rõ ràng tên model làm judge, mức temperature sử dụng, và báo cáo tỷ lệ đồng thuận với nhãn người kèm theo kích thước mẫu cụ thể để cả team có cái nhìn minh bạch nhất.

![Giữ bộ eval cố định và luôn đối chiếu judge với nhãn tay trước khi tin con số](https://assets.200lab.io/sha256/32/32daf486a6ba5890385abf0f256aa9cb898b697fcc78134992b45ca5bdde1db6/generations/01117981d9fa0ab79a8e64ea5dfc8fce0228600c5bc0ba83b3ddfc953104b498)

Mình chọn LLM-as-a-judge với đầu ra pass/fail kèm rubric tham chiếu khi cần tự động hóa kiểm tra tuân thủ chính sách và phát hiện lỗi bịa cam kết như câu Q11, còn việc gán nhãn chuẩn ban đầu và rà soát các trường hợp ngoại lệ dễ lệch như Q4 hay Q10 thì vẫn cần con người đối chiếu. Cách kết hợp này mở rộng được quy mô eval so với kiểu thử vài câu, còn nhãn người giúp bắt lại những chỗ máy chấm sai.

Nếu bạn muốn hiểu thêm cách chọn và dùng model sao cho phù hợp với từng bài toán kỹ thuật như thế này, bạn có thể xem qua khóa học bên dưới của 200Lab. Khóa này miễn phí, bạn chỉ cần đăng ký và bấm vào học miễn phí để tham gia.

![Hiểu model AI đủ để dùng và chọn đúng model - token, prompt caching, model card, reasoning model và fine-tune](https://assets.200lab.io/sha256/16/1686a8d85e2323887f566090f87cba32cba6f91366d26614d7b9f6d27571d347/generations/dad26be3b0dd1a4e42d407b61bb8002a2f873f5bb186a684933b069d6eddecc7)

- [Hiểu model AI đủ để dùng và chọn đúng model - token, prompt caching, model card, reasoning model và fine-tune](https://200lab.io/courses/understanding-ai-models-to-choose-the-right-one.md)

## Đọc thêm

- [Gemini Decisions API](/blog/gemini-decisions-api): cách chấm yes/no theo rubric kèm điểm confidence.
- [LangSmith là gì](/blog/langsmith-la-gi): công cụ theo dõi và chạy eval cho app LLM.
- [Ảo giác AI là gì, vì sao AI nói sai](/blog/ao-giac-ai-la-gi-vi-sao-ai-noi-sai): hiểu nguyên nhân model tự bịa thêm cam kết ngoài tài liệu gốc.
- [Các thuật ngữ LLM quan trọng](/blog/cac-thuat-ngu-llm-quan-trong): nắm rõ vai trò của temperature và các tham số khi gọi model.

## Đọc thêm

- [Gemini Decisions API: cổng chấm yes/no, choice và rubric của Google](https://200lab.io/blog/gemini-decisions-api.md): Gemini Decisions API chấm yes/no, chọn đáp án hoặc rubric kèm confidence trong một lượt. Google công bố latency 150-250 ms; bài tóm tắt từ docs, chưa gọi API.
- [Fine-tuning là gì? Khi nào chọn fine-tune, khi nào chọn RAG](https://200lab.io/blog/fine-tuning-la-gi.md): Fine tuning là gì: khi kiến thức hay đổi thì dùng RAG; muốn giữ format và giọng shop thì xét fine-tune hoặc LoRA.
- [Claude Fable 5.2 có gì mới và ưu đãi ra mắt cần biết](https://200lab.io/blog/claude-fable-5-2-whats-new.md): Claude Fable 5.2 được dùng trên app Claude với một số gói, hãy lưu ý hạn ưu đãi 16/11 và lưu dữ liệu 30 ngày; việc hằng ngày vẫn có thể bắt đầu với Opus 5.5.
- [Grok Bot gom phản hồi khách một tuần thành bảng việc cần sửa](https://200lab.io/blog/grok-bot-weekly-customer-feedback.md): Gom phản hồi khách bằng Grok Bot từ tin nhắn cả tuần: bạn có bảng khen chê kèm mã tin, ba việc cần sửa và tự đếm lại nhóm lớn nhất trước khi sửa shop.
- [Function calling là gì? Phân biệt với Structured Outputs và MCP](https://200lab.io/blog/function-calling-la-gi.md): Function calling nối model với dữ liệu thật qua host app: vòng tool call, các bước app phải kiểm tra, và điểm khác với Structured Outputs cùng MCP.
- [Mọi bài viết chủ đề AI](https://200lab.io/blog/tags/ai.md)

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