LLM 中的 20 个 AI 核心概念：详细解释与代码示例

1. 概述

如果你是正在将 LLM（ChatGPT、Gemini、Claude 等）集成到系统中的 Java 开发者，你会遇到很多陌生的术语：token、embedding、RAG、fine-tuning、hallucination 等。本文汇总了与 LLM 相关的 20 个最重要的 AI 概念，每个概念都附带简明解释和示例代码（主要使用 Java/Spring AI）。读完这篇文章，你就能看懂 OpenAI、Anthropic 的 API 文档，并能设计一个基础的 RAG 系统。

2. Token 和 Tokenization

LLM 不是读“字”而是读 token — 比单词更小的单位，可以是一个单词、部分单词或标点符号。Tokenization 是将文本拆分成这些 token 的过程，然后再输入到模型中。

输入：  "Spring Boot 很强大"
Token：["Spring", " Boot", " 很", " 强", " 大"]（5 个 token）

Token 数量决定了 API 调用的成本（按 token 计费）和输入/输出的长度限制。

注意： 带声调符号的语言通常比英文需要更多 token，因此用这类语言调用 API 的成本通常更高。

3. Embedding

Embedding 是将一段文本转换成一个 数值向量（例如 1536 维），使得语义相近的两段文本对应的向量也相近。这是语义搜索（semantic search）的基础。

EmbeddingModel embeddingModel = ...; // Spring AI 自动配置的 bean
EmbeddingResponse response = embeddingModel.embedForResponse(
        List.of("客户想取消订单"));
float[] vector = response.getResult().getOutput();
System.out.println(vector.length); // 1536

embedForResponse 调用 embedding 模型并返回向量。两句话“取消订单”和“cancel order”会有相近的向量，尽管语言不同。

为了比较语义相似度，我们使用 余弦相似度：

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);
}

接近 1 的值表示两个向量（因此也是两句话）语义相似度很高。

4. Context Window

Context window 是模型在一次调用中能“看到”的最大 token 总数 — 包括 prompt 和回复。超过这个限制，模型会截断前面的部分或返回错误。

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

对于有长对话历史的聊天机器人应用，你必须主动截断或总结旧的对话历史，否则 context window 满了，早期的对话内容会被丢失而你不会收到明确警告。

5. Prompt 和 Prompt Engineering

Prompt 是你发送给 LLM 的文本，用来要求它做什么。Prompt engineering 是设计 prompt 使模型按期望格式和内容回答的技术。

首先添加 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("用 1 句话总结客户的需求：" + orderNote)
                .call()
                .content();
    }
}

ChatClient 是 Spring AI 的包装器，帮助你调用模型而无需自己处理 HTTP。.user(...) 设置 prompt 内容，.call().content() 返回结果字符串。

6. System Prompt vs User Prompt

System prompt 是“隐性”指令，定义模型在整个对话中的角色和规则；user prompt 是用户的具体问题或请求。

chatClient.prompt()
        .system("你是鞋店的客户支持助手。回答时要简洁、礼貌。")
        .user("我的订单 #1023 什么时候送到？")
        .call()
        .content();

System prompt 只需设置一次，user prompt 随着每个请求改变。分离这两种 prompt 类型让你能控制模型的“性格”，而不必在每个问题中重复说明。

7. Zero-shot、One-shot 和 Few-shot Learning

这些是在 prompt 中提供（或不提供）示例样本的方式，使模型按期望的格式回答，无需对模型进行 fine-tuning。

Zero-shot: 没有示例，只有任务描述。
Few-shot:  有 2-5 个示例（输入 → 输出）在实际问题之前。

String fewShotPrompt = """
    对评论进行情感分类（positive/negative）：
    评论："快速发货，质量好" -> positive
    评论："产品有问题，晚到一周" -> negative
    评论："%s" ->
    """.formatted(userReview);

Few-shot 通常比 zero-shot 对分类或特定格式的任务更稳定，但每次调用会消耗更多 token。

8. Chain-of-Thought（CoT）

CoT 是要求模型在给出最终答案前“逐步思考”的技术，帮助提高需要推理的任务（数学、逻辑）的准确率。

chatClient.prompt()
        .user("""
            一个订单有 3 件商品，价格分别为 120k、85k、45k，打 9 折。
            请逐步计算然后给出最终总价。
            """)
        .call()
        .content();

当要求“逐步”计算时，模型倾向于把问题分解成更小的步骤，减少直接计算时出错的可能性。

9. Temperature 和 Top-p

Temperature 和 top-p 是两个参数，控制模型选择下一个 token 时的“随机性”。Temperature 低 → 回答一致、重复；高 → 更有创意但容易偏离主题。

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

temperature = 0.0  -> 适用：数据提取、精确回答
temperature = 0.8  -> 适用：创意写作、头脑风暴

注意： 对于需要可重复结果的任务（例如自动化测试），应设置 temperature = 0 以减少多次调用间的变化。

10. Attention Mechanism

Attention 是模型在处理一个词时，自动评估该句中所有其他词的相关性并给予权重的机制。这就是为什么模型能理解远距离的语境，例如代词“它”指的是哪个名词。

句子："订单因为客户改主意被取消，它已经退款。"
Attention 帮助模型理解"它"指的是"订单"而非"客户"。

使用 API 时你不需要直接编写 attention 代码，但理解它有助于解释为什么模型有时会“忘记”很远的上文或处理太长的文本时信息丢失。

11. Transformer Architecture

Transformer 是当今几乎所有 LLM 的基础神经网络架构，使用 attention 同时（并行）处理整个句子，而不是像旧的 RNN 那样逐个处理，因此在海量数据上训练更快。

输入 token -> Embedding -> [Attention + Feed-Forward] × N 层 -> 输出概率

层数（N）和参数总数决定了模型的“规模” — GPT-4、Claude、Llama 都是 Transformer 的变种，但层数和训练方式不同。

12. Fine-tuning

Fine-tuning 是在一个预训练模型的基础上用你的私有数据继续训练，使其专门化于某个特定任务（例如：用你品牌的语气回答问题）。

{"messages": [
  {"role": "user", "content": "订单 #203 什么时候送到？"},
  {"role": "assistant", "content": "订单 #203 已在路上，预计今天送达。"}
]}

这个 JSONL 文件的一行是一条训练数据 — 每行是一对示例对话，你需要发送数千行这样的数据给 provider 的 fine-tuning API。

何时不用： 如果你只需要模型遵循几个简单规则，prompt engineering 或 RAG 比 fine-tuning 便宜且快得多。

13. LoRA（Low-Rank Adaptation）

LoRA 是一种节省资源的 fine-tuning 技术：与其更新模型的数十亿参数，LoRA 只训练一些小的矩阵“插件”，保持原模型不变。

原模型：70 亿参数（冻结，不变）
LoRA 适配器：约 1000-5000 万参数（被训练）

这样，LoRA 可以在普通 GPU 上 fine-tune 大型模型，并且能对同一模型套用多个不同的 adapter 以处理不同的 use case。

14. Quantization

Quantization 是降低模型参数的数值精度（例如从 float32 降到 int8/int4）以减小大小和加快推理速度，代价是牺牲一点精度。

FP32: 70 亿参数 × 4 字节 = 约 28GB 内存
INT4: 70 亿参数 × 0.5 字节 = 约 3.5GB 内存

Quantization 就是为什么你能在普通笔记本上运行 70 亿参数的 LLM，而不需要专门的 GPU 服务器 — 代价是回答质量略微下降。

15. RAG（Retrieval-Augmented Generation）

RAG 结合检索和 LLM：在回答前，系统通过 embedding 找出最相关的内部文本段，将其作为“背景”加入 prompt，帮助模型基于你的实际数据回答，无需 fine-tuning。

List<Document> relevantDocs = vectorStore.similaritySearch(
        SearchRequest.query("商品退货政策").withTopK(3));

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

String answer = chatClient.prompt()
        .system("仅基于提供的背景信息回答。")
        .user("背景：\n" + context + "\n\n问题：可以在多少天内退货？")
        .call()
        .content();

similaritySearch 找到与问题最相似的 3 个文档段落，将其合并进 prompt 再发给模型。这样答案就基于你真实的政策，而不是模型预训练时学到的笼统知识。

16. Vector Database

Vector database 是存储 embedding 向量及其元数据的数据库，支持快速的“K 最近邻”（k-NN）搜索 — 这是大规模 RAG 应用的必需组件（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;

<-> 运算符（由 pgvector 扩展提供）计算查询向量与已存储向量间的距离，返回最接近的记录 — 这正是第 15 部分中 similaritySearch 的实现原理。

17. Function Calling / Tool Use

Function calling 让 LLM“请求”你的应用调用某个特定函数（查价格、查天气、查询 DB），而不是自己编造数据。

@Tool(description = "根据订单号获取订单状态")
String getOrderStatus(String orderId) {
    return orderRepository.findStatusById(orderId);
}

chatClient.prompt()
        .user("订单 #1023 状态是什么？")
        .tools(this)
        .call()
        .content();

发送问题时，模型自动识别需要调用 getOrderStatus，Spring AI 执行真实的 Java 函数，获取结果再交回模型以生成最终答案 — 模型不再需要“猜测”订单状态。

18. AI Agent

Agent 是一个系统，用 LLM 作为“大脑”来自主计划、按顺序调用多个 tool、观察结果并迭代，直到完成目标 — 与只回答一次的聊天机器人不同。

用户："检查订单 #1023，如果超期超过 3 天就给客户发道歉邮件。"

Agent 自动执行：
1. 调用 tool getOrderStatus("1023")
2. 计算超期天数
3. 如果 > 3 天 -> 调用 tool sendEmail(...)
4. 向用户报告结果

Agent 通常通过“思考 → 行动 → 观察”的循环实现（ReAct 模式），组合多个连续的 function calling 来处理多步骤任务。

19. Hallucination

Hallucination 是模型自信但错误或完全虚构信息的现象 — 例如引用一个不存在的法律条款，或错误记忆一个 API 不实际存在。

用户："API `OrderService.cancelAndRefund()` 怎么用？"
模型："该方法会在 24 小时内自动退款..." （但此方法在代码库中不存在）

最常见的减少 hallucination 的方法是使用 RAG（第 15 部分）让模型基于真实文档回答，并要求模型在信息不足时回答“我不知道”而不是自己推测。

20. Guardrails

Guardrails 是围绕 LLM 的一组控制层（输入/输出过滤、格式验证、敏感内容阻止），确保系统安全且符合标准后再返回给最终用户。

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

if (containsPersonalData(output) || !isValidJson(output)) {
    throw new UnsafeModelOutputException("输出不符合 guardrail 标准");
}

Guardrails 可以在输入端（阻止 prompt 注入、有害内容）或输出端（检查 JSON 格式、隐藏银行卡号）— 即使模型在演示时看起来回答正确，也不应忽略这一步。

21. RLHF（Reinforcement Learning from Human Feedback）

RLHF 是基于人类反馈来训练模型的技术：人类给模型的多个回答排序，由此训练一个“奖励模型”来继续优化原模型，使其更有帮助和安全。

第 1 步：模型对同一问题生成 3-4 个答案
第 2 步：人类排序：最好 -> 最差
第 3 步：训练奖励模型学会像人一样"评分"
第 4 步：用奖励模型通过强化学习优化 LLM

RLHF 就是为什么 ChatGPT、Claude 的回答礼貌有道、会拒绝危险请求 — 而不仅仅是预训练模型那样的“猜测下一个词”。

22. 总结

上述 20 个概念是与 LLM 协作的最少必需词汇：从低层（token、embedding、attention）到应用层（RAG、function calling、agent、guardrails）。你不需要深入理解 Transformer 的数学才能将 LLM 集成到 Spring Boot 系统中，但正确理解这些概念能帮你选择合适的方案 — 比如知道何时用 RAG 而非 fine-tuning，何时需要 guardrail 而非盲目信任模型输出。