Top 20 khái niệm AI trong LLM: giải thích chi tiết kèm ví dụ

1. Tổng quan

Nếu bạn là dev Java bắt đầu tích hợp LLM (ChatGPT, Gemini, Claude…) vào hệ thống, bạn sẽ gặp rất nhiều thuật ngữ lạ: token, embedding, RAG, fine-tuning, hallucination… Bài này tổng hợp 20 khái niệm AI quan trọng nhất liên quan đến LLM, mỗi khái niệm có giải thích ngắn và ví dụ minh họa (phần lớn bằng Java/Spring AI). Đọc xong, bạn đủ vốn từ để đọc tài liệu API của OpenAI, Anthropic hay thiết kế một hệ thống RAG cơ bản.

2. Token và Tokenization

LLM không đọc “chữ” mà đọc token — đơn vị nhỏ hơn từ, có thể là một từ, một phần từ, hoặc dấu câu. Tokenization là bước băm văn bản thành các token này trước khi đưa vào model.

Input:  "Spring Boot rất mạnh"
Tokens: ["Spring", " Boot", " rất", " mạnh"]  (4 tokens)

Số token quyết định chi phí gọi API (billing theo token) và giới hạn độ dài input/output.

Lưu ý: Tiếng Việt có dấu thường bị tách thành nhiều token hơn tiếng Anh cho cùng một câu, nên chi phí gọi API cho nội dung tiếng Việt thường cao hơn.

3. Embedding

Embedding là việc biến một đoạn text thành một vector số thực (ví dụ 1536 chiều), sao cho hai đoạn text có nghĩa gần nhau thì vector gần nhau. Đây là nền tảng cho tìm kiếm ngữ nghĩa (semantic search).

EmbeddingModel embeddingModel = ...; // bean do Spring AI tự cấu hình
EmbeddingResponse response = embeddingModel.embedForResponse(
        List.of("Khách hàng muốn hủy đơn hàng"));
float[] vector = response.getResult().getOutput();
System.out.println(vector.length); // 1536

embedForResponse gọi model embedding và trả về vector. Hai câu “hủy đơn hàng” và “cancel order” sẽ có vector gần nhau dù ngôn ngữ khác nhau.

Để so sánh độ gần nghĩa, ta dùng cosine similarity:

double cosineSimilarity(float[] a, float[] b) {
    double dot = 0, normA = 0, normB = 0;
    for (int i = 0; i < a.length; i++) {
        dot += a[i] * b[i];
        normA += a[i] * a[i];
        normB += b[i] * b[i];
    }
    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

@Test
void similarVectorsShouldScoreHigh() {
    float[] a = {1f, 0f, 1f};
    float[] b = {1f, 0.1f, 0.9f};
    assertThat(cosineSimilarity(a, b)).isGreaterThan(0.95);
}

Giá trị gần 1 nghĩa là hai vector (và do đó hai câu) rất gần nghĩa nhau.

4. Context Window

Context window là tổng số token tối đa mà model “nhìn thấy” trong một lần gọi — bao gồm cả prompt lẫn phần trả lời. Vượt quá giới hạn này, model sẽ cắt bỏ phần đầu hoặc trả lỗi.

GPT-4o:        128,000 tokens
Claude 3.5:    200,000 tokens
Gemini 1.5 Pro: 1,000,000 tokens

Với ứng dụng chatbot có lịch sử hội thoại dài, bạn phải chủ động cắt/tóm tắt lịch sử cũ trước khi context window đầy, nếu không sẽ mất thông tin đầu cuộc trò chuyện mà không có cảnh báo rõ ràng.

5. Prompt và Prompt Engineering

Prompt là đoạn text bạn gửi cho LLM để yêu cầu nó làm gì. Prompt engineering là kỹ thuật thiết kế prompt để model trả lời đúng ý, đúng format mong muốn.

Trước tiên, thêm dependency Spring AI:

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

@Service
class OrderSummaryService {
    private final ChatClient chatClient;

    OrderSummaryService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    String summarize(String orderNote) {
        return chatClient.prompt()
                .user("Tóm tắt yêu cầu khách hàng trong 1 câu: " + orderNote)
                .call()
                .content();
    }
}

ChatClient là wrapper của Spring AI giúp gọi model mà không cần tự xử lý HTTP. .user(...) thiết lập nội dung prompt, .call().content() trả về chuỗi kết quả.

6. System Prompt vs User Prompt

System prompt là chỉ dẫn “ngầm” định hình vai trò và quy tắc của model trong suốt cuộc hội thoại; user prompt là câu hỏi/yêu cầu cụ thể của người dùng.

chatClient.prompt()
        .system("Bạn là trợ lý hỗ trợ khách hàng của shop giày. Luôn trả lời ngắn gọn, lịch sự.")
        .user("Đơn #1023 của tôi khi nào giao?")
        .call()
        .content();

System prompt chỉ cần set một lần, user prompt thay đổi theo từng request. Tách hai loại này giúp bạn kiểm soát “tính cách” model mà không lặp lại hướng dẫn trong mỗi câu hỏi.

7. Zero-shot, One-shot, Few-shot Learning

Đây là cách bạn cung cấp (hoặc không cung cấp) ví dụ mẫu trong prompt để model học cách trả lời theo format mong muốn, mà không cần fine-tuning lại model.

Zero-shot: Không có ví dụ, chỉ có mô tả yêu cầu.
Few-shot:  Có 2-5 ví dụ input -> output mẫu trước khi đưa câu hỏi thật.

String fewShotPrompt = """
    Phân loại cảm xúc review (positive/negative):
    Review: "Giao hàng nhanh, chất lượng tốt" -> positive
    Review: "Sản phẩm lỗi, giao trễ 1 tuần" -> negative
    Review: "%s" ->
    """.formatted(userReview);

Few-shot thường cho kết quả ổn định hơn zero-shot với các task phân loại/format đặc thù, đổi lại tốn nhiều token hơn mỗi lần gọi.

8. Chain-of-Thought (CoT)

CoT là kỹ thuật yêu cầu model “suy nghĩ từng bước” trước khi đưa câu trả lời cuối, giúp tăng độ chính xác với bài toán cần lập luận (toán, logic).

chatClient.prompt()
        .user("""
            Một đơn hàng có 3 sản phẩm giá 120k, 85k, 45k, giảm giá 10%.
            Hãy tính từng bước rồi đưa ra tổng tiền cuối cùng.
            """)
        .call()
        .content();

Khi được yêu cầu “từng bước”, model có xu hướng tự phân rã bài toán thành các phép tính nhỏ, giảm khả năng tính sai so với việc hỏi trực tiếp “tổng tiền là bao nhiêu?”.

9. Temperature và Top-p

Temperature và top-p là hai tham số điều chỉnh độ “ngẫu nhiên” khi model chọn từ tiếp theo. Temperature thấp → trả lời nhất quán, lặp lại; cao → sáng tạo hơn nhưng dễ lệch chủ đề.

ChatOptions options = OpenAiChatOptions.builder()
        .withTemperature(0.2)
        .withTopP(0.9)
        .build();

temperature = 0.0  -> phù hợp: trích xuất dữ liệu, trả lời chính xác
temperature = 0.8  -> phù hợp: viết nội dung sáng tạo, brainstorm

Lưu ý: Với tác vụ cần kết quả tái lập được (ví dụ test tự động), nên set temperature = 0 để giảm biến động giữa các lần gọi.

10. Attention Mechanism

Attention là cơ chế cho phép model, khi xử lý một từ, “nhìn” vào mọi từ khác trong câu và tự tính trọng số xem từ nào liên quan nhất. Đây là lý do model hiểu được ngữ cảnh xa, ví dụ đại từ “nó” trỏ về danh từ nào.

Câu: "Đơn hàng bị hủy vì khách đổi ý, nó đã được hoàn tiền."
Attention giúp model liên kết "nó" -> "Đơn hàng", không phải "khách".

Bạn không code trực tiếp attention khi dùng API, nhưng hiểu nó giúp giải thích tại sao model đôi khi “quên” ngữ cảnh ở câu quá xa hoặc quá dài.

11. Transformer Architecture

Transformer là kiến trúc neural network nền tảng của gần như mọi LLM hiện nay, dùng attention để xử lý toàn bộ câu đồng thời (song song) thay vì tuần tự như RNN cũ, nhờ vậy huấn luyện nhanh hơn trên dữ liệu khổng lồ.

Input tokens -> Embedding -> [Attention + Feed-Forward] x N layers -> Output probabilities

Số layer (N) và số tham số (parameters) quyết định “kích thước” model — GPT-4, Claude, Llama đều là biến thể của Transformer với số layer và cách huấn luyện khác nhau.

12. Fine-tuning

Fine-tuning là huấn luyện tiếp một model đã có sẵn (pretrained) trên dữ liệu riêng của bạn, để nó chuyên biệt hóa cho một task cụ thể (ví dụ: trả lời đúng tông giọng thương hiệu).

{"messages": [
  {"role": "user", "content": "Đơn #203 giao chưa?"},
  {"role": "assistant", "content": "Dạ đơn #203 đang trên đường giao, dự kiến đến trong hôm nay ạ."}
]}

File JSONL này là một dòng dữ liệu huấn luyện mẫu cho fine-tuning — mỗi dòng là một cặp hội thoại mẫu, gửi hàng nghìn dòng như vậy cho API fine-tuning của provider.

Khi nào KHÔNG nên dùng: nếu chỉ cần model trả lời theo một số quy tắc đơn giản, prompt engineering hoặc RAG rẻ hơn và nhanh hơn fine-tuning rất nhiều.

13. LoRA (Low-Rank Adaptation)

LoRA là kỹ thuật fine-tuning tiết kiệm: thay vì cập nhật toàn bộ hàng tỉ tham số của model gốc, LoRA chỉ huấn luyện một số ma trận nhỏ “chèn thêm” vào các layer, giữ nguyên model gốc.

Model gốc: 7 tỷ tham số (đóng băng, không đổi)
LoRA adapter: ~10-50 triệu tham số (được huấn luyện)

Nhờ vậy, LoRA cho phép fine-tune model lớn trên một GPU thông thường, và có thể “tháo gắn” nhiều adapter khác nhau cho nhiều use case trên cùng một model gốc.

14. Quantization

Quantization là giảm độ chính xác số học của tham số model (ví dụ từ float32 xuống int8/int4) để giảm kích thước và tăng tốc inference, đánh đổi một chút độ chính xác.

FP32: 7B params x 4 bytes = ~28 GB RAM
INT4: 7B params x 0.5 byte = ~3.5 GB RAM

Quantization là lý do bạn có thể chạy một LLM 7 tỷ tham số trên laptop thông thường thay vì cần server GPU chuyên dụng — đổi lại chất lượng câu trả lời giảm nhẹ.

15. RAG (Retrieval-Augmented Generation)

RAG là kỹ thuật kết hợp tìm kiếm (retrieval) dữ liệu nội bộ với LLM: trước khi trả lời, hệ thống tìm các đoạn text liên quan nhất (qua embedding) và đưa vào prompt làm “ngữ cảnh”, giúp model trả lời đúng dữ liệu riêng của bạn mà không cần fine-tuning.

List<Document> relevantDocs = vectorStore.similaritySearch(
        SearchRequest.query("chính sách đổi trả hàng").withTopK(3));

String context = relevantDocs.stream()
        .map(Document::getContent)
        .collect(Collectors.joining("\n---\n"));

String answer = chatClient.prompt()
        .system("Chỉ trả lời dựa trên ngữ cảnh được cung cấp.")
        .user("Ngữ cảnh:\n" + context + "\n\nCâu hỏi: Đổi trả trong bao nhiêu ngày?")
        .call()
        .content();

similaritySearch tìm 3 đoạn tài liệu gần nghĩa nhất với câu hỏi, ghép vào prompt rồi mới gửi cho model. Nhờ vậy câu trả lời bám sát chính sách thật của bạn, không phải kiến thức “chung chung” model học được lúc pretrain.

16. Vector Database

Vector database là nơi lưu trữ các embedding kèm metadata, hỗ trợ tìm kiếm “k láng giềng gần nhất” (k-NN) nhanh trên hàng triệu vector — thành phần bắt buộc để RAG chạy ở quy mô lớn (Pinecone, Milvus, PGVector…).

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(1536)
);

SELECT content FROM documents
ORDER BY embedding <-> '[0.01, -0.02, ...]'
LIMIT 3;

Toán tử <-> (do extension pgvector cung cấp) tính khoảng cách giữa vector câu hỏi và vector đã lưu, trả về các bản ghi gần nhất — đây chính là bước similaritySearch ở mục 15.

17. Function Calling / Tool Use

Function calling cho phép LLM “yêu cầu” ứng dụng của bạn gọi một hàm cụ thể (tra giá, tra thời tiết, truy vấn DB) khi nó thấy cần, thay vì tự bịa dữ liệu.

@Tool(description = "Lấy trạng thái đơn hàng theo mã đơn")
String getOrderStatus(String orderId) {
    return orderRepository.findStatusById(orderId);
}

chatClient.prompt()
        .user("Đơn #1023 đang ở trạng thái gì?")
        .tools(this)
        .call()
        .content();

Khi gửi câu hỏi, model tự nhận ra cần gọi getOrderStatus, Spring AI thực thi hàm Java thật, lấy kết quả rồi đưa lại cho model để soạn câu trả lời cuối — model không còn phải “đoán” trạng thái đơn hàng.

18. AI Agent

Agent là hệ thống dùng LLM làm “bộ não” để tự lên kế hoạch, gọi nhiều tool theo trình tự, quan sát kết quả và lặp lại cho đến khi hoàn thành mục tiêu — khác với chatbot chỉ trả lời một lượt.

User: "Kiểm tra đơn #1023, nếu trễ hơn 3 ngày thì gửi email xin lỗi khách."

Agent tự thực hiện:
1. Gọi tool getOrderStatus("1023")
2. Tính số ngày trễ
3. Nếu > 3 -> gọi tool sendEmail(...)
4. Trả báo cáo cho user

Agent thường được xây bằng vòng lặp “suy nghĩ → hành động → quan sát” (ReAct pattern), kết hợp nhiều function calling liên tiếp để xử lý một nhiệm vụ có nhiều bước.

19. Hallucination

Hallucination là khi model trả lời một cách tự tin nhưng thông tin đó sai hoặc hoàn toàn bịa đặt — ví dụ trích dẫn một điều luật không tồn tại, hoặc nhớ nhầm API không có thật.

User: "API `OrderService.cancelAndRefund()` hoạt động thế nào?"
Model: "Phương thức này tự động hoàn tiền trong 24h..." (nhưng phương thức này không tồn tại trong codebase)

Cách giảm hallucination phổ biến nhất là dùng RAG (mục 15) để model bám vào tài liệu thật, và yêu cầu model trả lời “tôi không biết” khi ngữ cảnh không đủ thông tin, thay vì tự suy diễn.

20. Guardrails

Guardrails là tập các lớp kiểm soát (filter input/output, validate format, chặn nội dung nhạy cảm) đặt quanh LLM để đảm bảo hệ thống an toàn và đúng chuẩn trước khi trả kết quả cho người dùng cuối.

String output = chatClient.prompt().user(userInput).call().content();

if (containsPersonalData(output) || !isValidJson(output)) {
    throw new UnsafeModelOutputException("Output không đạt chuẩn guardrail");
}

Guardrails có thể nằm ở input (chặn prompt injection, nội dung độc hại) hoặc output (kiểm tra format JSON, che số thẻ ngân hàng) — không nên bỏ qua bước này khi đưa LLM vào sản phẩm thật, kể cả khi model “có vẻ” trả lời đúng trong lúc demo.

21. RLHF (Reinforcement Learning from Human Feedback)

RLHF là kỹ thuật huấn luyện model dựa trên phản hồi con người: con người xếp hạng nhiều câu trả lời của model, từ đó huấn luyện một “reward model” để tiếp tục tối ưu model gốc sao cho trả lời hữu ích và an toàn hơn.

Bước 1: Model sinh 3-4 câu trả lời cho cùng một câu hỏi
Bước 2: Con người xếp hạng: tốt nhất -> tệ nhất
Bước 3: Huấn luyện reward model học cách "chấm điểm" như con người
Bước 4: Dùng reward model để fine-tune LLM qua reinforcement learning

RLHF là lý do ChatGPT, Claude trả lời có “giọng” lịch sự, từ chối yêu cầu nguy hiểm — khác hẳn model gốc chỉ được huấn luyện để “đoán từ tiếp theo” thuần túy.

22. Kết luận

20 khái niệm trên là bộ từ vựng tối thiểu để bạn làm việc nghiêm túc với LLM: từ tầng thấp (token, embedding, attention) đến tầng ứng dụng (RAG, function calling, agent, guardrails). Bạn không cần hiểu sâu toán học của Transformer để tích hợp LLM vào hệ thống Spring Boot, nhưng hiểu đúng các khái niệm này giúp bạn chọn giải pháp phù hợp — ví dụ biết khi nào dùng RAG thay vì fine-tuning, khi nào cần guardrail thay vì tin tưởng tuyệt đối vào output của model.