在这里插入图片描述

🍃 予枫：个人主页

📚 个人专栏: 《Java 从入门到起飞》《读研码农的干货日常》

💻 Debug 这个世界，Return 更好的自己！

引言

作为Java开发者，想入门大模型开发却被LLM、Token、RAG等术语搞得一头雾水？看着AI领域的技术文章，满屏陌生概念难以代入？本文专为Java开发者量身打造，用Java语言拆解10个大模型核心术语，每个术语配套极简代码示例，梳理术语间的关联链路，纠正入门常见误区，帮你快速打通Java与大模型开发的衔接壁垒～

文章目录

一、核心术语拆解（含Java极简示例）

大模型开发的术语看似繁杂，但只要结合Java开发思维去理解，就能快速掌握核心逻辑。以下10个术语是Java开发者入门大模型的必备基础，每个术语均配套可直接参考的极简代码片段，拒绝纯理论空谈。

1. LLM（大语言模型）

定义：Large Language Model，即大语言模型，是基于海量文本数据训练的深度学习模型，能理解和生成人类语言，是大模型开发的核心载体。对Java开发者而言，LLM就像一个“智能语言处理器”，我们通过Java SDK调用其能力，实现对话、生成等功能。

✅ 误区纠正：LLM不是“万能的”，它无法直接执行Java代码逻辑，需通过工具调用（Tool Calling）实现与Java程序的交互。

Java极简示例（以调用OpenAI LLM为例，使用官方SDK）：

// 引入依赖（Maven）
// <dependency>
//     <groupId>com.openai</groupId>
//     <artifactId>openai-java</artifactId>
//     <version>0.18.0</version>
// </dependency>

import com.openai.OpenAiClient;
import com.openai.models.CompletionRequest;

public class LLMTest {
    public static void main(String[] args) {
        // 初始化LLM客户端
        OpenAiClient client = OpenAiClient.builder()
                .apiKey("你的API_KEY")
                .build();
        // 调用LLM生成文本
        CompletionRequest request = CompletionRequest.builder()
                .model("gpt-3.5-turbo-instruct")
                .prompt("用Java语言解释什么是LLM")
                .maxTokens(100)
                .build();
        String result = client.completions().create(request).getChoices().get(0).getText();
        System.out.println("LLM生成结果：" + result);
    }
}

2. Prompt（提示词）

定义：Prompt是用户向LLM发送的指令或问题，是LLM生成符合预期结果的“导航仪”。对Java开发者而言，Prompt设计的好坏，直接决定LLM的输出质量，常用的Prompt技巧有指令式、示例式、角色设定等。

💡 小技巧：Java开发中，可将常用Prompt封装成常量，通过字符串拼接动态生成Prompt，提升代码复用性。

Java极简示例：

public class PromptDemo {
    // 封装Prompt模板（角色设定+指令）
    private static final String PROMPT_TEMPLATE = "你是一名资深Java开发者，请用简洁的语言解释：%s，要求不超过50字。";
    
    public static void main(String[] args) {
        // 动态拼接Prompt
        String prompt = String.format(PROMPT_TEMPLATE, "Embedding的核心作用");
        System.out.println("生成的Prompt：" + prompt);
        // 后续可将prompt传入LLM客户端，获取生成结果
    }
}

3. Token（令牌）

定义：Token是LLM处理文本的最小单位，1个Token约等于4个英文字符或2个中文字符（含标点、空格）。LLM的调用成本、生成长度均以Token为单位计算，Java开发者需关注Token数量，避免超出模型限制。

✅ 误区纠正：Token不是“字符数”，换行、空格、标点都会被计入Token，需通过工具计算Token数量（如OpenAI的tiktoken库）。

Java极简示例（计算文本Token数量）：

import com.openai.tokenizer.Tiktoken;

public class TokenTest {
    public static void main(String[] args) {
        String text = "Java开发者必懂的大模型10个核心术语";
        // 初始化tokenizer（对应gpt-3.5-turbo模型）
        Tiktoken tokenizer = Tiktoken.encodingForModel("gpt-3.5-turbo");
        // 计算Token数量
        int tokenCount = tokenizer.encode(text).size();
        System.out.println("文本Token数量：" + tokenCount); // 输出约15个Token
    }
}

4. Embedding（嵌入）

定义：Embedding是将文本、图片等信息转换成高维向量的过程，生成的向量能反映信息的语义特征，是大模型实现语义检索、相似性对比的核心技术。对Java开发者而言，Embedding常用来处理文本匹配、知识库检索等场景。

Java极简示例（生成文本Embedding）：

import com.openai.OpenAiClient;
import com.openai.models.EmbeddingRequest;

public class EmbeddingDemo {
    public static void main(String[] args) {
        OpenAiClient client = OpenAiClient.builder()
                .apiKey("你的API_KEY")
                .build();
        // 生成文本Embedding
        EmbeddingRequest request = EmbeddingRequest.builder()
                .model("text-embedding-ada-002")
                .input("Java大模型开发核心术语")
                .build();
        // 获取Embedding向量（高维数组）
        double[] embedding = client.embeddings().create(request)
                .getData().get(0).getEmbedding().stream()
                .mapToDouble(Double::doubleValue)
                .toArray();
        System.out.println("Embedding向量长度：" + embedding.length); // 输出1536维
    }
}

5. 向量数据库

定义：向量数据库是专门用于存储、检索Embedding向量的数据库，支持高效的相似性查询（如余弦相似度），解决了传统关系型数据库无法高效处理高维向量的问题，是RAG技术的核心组件之一。Java开发者常用的向量数据库有Milvus、Pinecone、Chroma等。

Java极简示例（Milvus向量数据库插入向量）：

// 引入依赖（Maven）
// <dependency>
//     <groupId>io.milvus</groupId>
//     <artifactId>milvus-sdk-java</artifactId>
//     <version>2.4.0</version>
// </dependency>

import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusClientBuilder;
import io.milvus.param.collection.InsertParam;
import io.milvus.response.InsertResponse;

import java.util.ArrayList;
import java.util.List;

public class VectorDbDemo {
    public static void main(String[] args) {
        // 连接Milvus向量数据库
        MilvusClient client = new MilvusClientBuilder()
                .withHost("localhost")
                .withPort(19530)
                .build();
        // 模拟Embedding向量（1536维）
        List&lt;Float&gt; vector = new ArrayList<>();
        for (int i = 0; i < 1536; i++) {
            vector.add((float) Math.random());
        }
        // 插入向量
        InsertParam insertParam = InsertParam.builder()
                .collectionName("java_llm_embedding")
                .addVectorField("embedding", List.of(vector))
                .build();
        InsertResponse response = client.insert(insertParam);
        System.out.println("向量插入成功，插入行数：" + response.getInsertCount());
    }
}

6. RAG（检索增强生成）

定义：Retrieval-Augmented Generation，即检索增强生成，是将“检索外部知识库”与“LLM生成”结合的技术。通过检索获取精准信息，再让LLM基于这些信息生成回答，解决了LLM知识滞后、生成内容不准确的问题，是Java大模型应用的核心架构之一。

💡 核心链路（Java视角）：用户提问 → Java程序调用向量数据库检索相关信息 → 将检索结果与Prompt拼接 → 调用LLM生成回答。

Java极简示例（RAG核心流程简化版）：

public class RAGDemo {
    // 模拟向量数据库检索（实际需调用向量数据库SDK）
    private static String retrieveFromVectorDb(String question) {
        // 1. 将用户问题转换成Embedding
        // 2. 调用向量数据库检索相似文本
        // 3. 返回检索到的知识库内容
        return "RAG是检索增强生成技术，能提升LLM回答的准确性，核心依赖向量数据库检索。";
    }
    
    // 调用LLM生成回答（复用之前的LLM调用逻辑）
    private static String generateAnswer(String prompt) {
        // 此处省略LLM调用代码，参考前面的LLM示例
        return "根据检索到的信息，RAG技术的核心是将检索与生成结合，解决LLM知识滞后问题，Java开发中可通过向量数据库+LLM SDK实现。";
    }
    
    public static void main(String[] args) {
        String userQuestion = "什么是RAG？Java如何实现？";
        // 1. 检索外部知识库
        String retrievedInfo = retrieveFromVectorDb(userQuestion);
        // 2. 拼接Prompt（检索结果+用户问题）
        String prompt = String.format("用户问题：%s\n参考信息：%s\n请用Java开发者能听懂的话回答，不超过100字。", userQuestion, retrievedInfo);
        // 3. 调用LLM生成回答
        String answer = generateAnswer(prompt);
        System.out.println("RAG生成回答：" + answer);
    }
}

7. Tool Calling（工具调用）

定义：Tool Calling是LLM调用外部工具（如Java程序、API接口、数据库）的能力，让LLM从“只能生成文本”升级为“能执行具体操作”。对Java开发者而言，Tool Calling是实现大模型与Java业务系统集成的关键，比如让LLM调用Java接口查询数据库、执行业务逻辑。

Java极简示例（LLM调用Java工具查询数据库）：

import com.openai.OpenAiClient;
import com.openai.models.ChatCompletionRequest;
import com.openai.models.ChatMessage;
import com.openai.models.ChatMessageRole;

import java.util.List;

public class ToolCallingDemo {
    // 模拟Java工具：查询数据库用户数量
    private static int queryUserCount() {
        // 实际场景中是JDBC查询逻辑
        return 1000;
    }
    
    public static void main(String[] args) {
        OpenAiClient client = OpenAiClient.builder()
                .apiKey("你的API_KEY")
                .build();
        // 1. 构造Prompt，让LLM调用工具
        ChatMessage systemMsg = new ChatMessage(
                ChatMessageRole.SYSTEM,
                "你可以调用工具queryUserCount()查询用户数量，工具返回整数，无需额外解释，直接调用即可。"
        );
        ChatMessage userMsg = new ChatMessage(
                ChatMessageRole.USER,
                "查询当前系统的用户总数是多少？"
        );
        // 2. 调用LLM，获取工具调用指令
        ChatCompletionRequest request = ChatCompletionRequest.builder()
                .model("gpt-3.5-turbo")
                .messages(List.of(systemMsg, userMsg))
                .build();
        String toolCall = client.chatCompletions().create(request).getChoices().get(0).getMessage().getContent();
        
        // 3. 解析工具调用指令，执行Java工具
        int userCount = 0;
        if (toolCall.contains("queryUserCount()")) {
            userCount = queryUserCount();
        }
        // 4. 将工具执行结果返回给LLM，生成最终回答
        String finalPrompt = String.format("工具调用结果：用户总数为%d，请简洁回答用户问题。", userCount);
        // 此处省略最终LLM调用逻辑，输出结果即可
        System.out.println("用户总数：" + userCount);
    }
}

8. Agent（智能代理）

定义：Agent是具备“自主思考、规划、执行”能力的大模型应用，能根据用户需求，自主决定是否调用工具、调用哪些工具、如何执行步骤，无需人工干预。对Java开发者而言，Agent是大模型应用的高级形态，可实现复杂业务场景（如自动生成Java代码、排查系统问题）。

✅ 误区纠正：Agent不是“单一工具”，而是“LLM+Tool Calling+逻辑规划”的组合体，Java开发中需封装规划逻辑，让Agent能自主决策。

Java极简示例（Agent自主规划逻辑简化版）：

public class AgentDemo {
    // 模拟Agent规划逻辑：根据用户需求，决定调用哪些工具
    private static String planTool(String user需求) {
        if (user需求.contains("代码")) {
            return "调用代码生成工具";
        } else if (user需求.contains("查询")) {
            return "调用数据库查询工具";
        } else {
            return "无需调用工具，直接用LLM回答";
        }
    }
    
    // 模拟工具执行
    private static String executeTool(String toolName) {
        if ("调用代码生成工具".equals(toolName)) {
            return "生成Java冒泡排序代码：public void bubbleSort(int[] arr) {...}";
        } else if ("调用数据库查询工具".equals(toolName)) {
            return "数据库查询结果：用户总数1000";
        } else {
            return "";
        }
    }
    
    public static void main(String[] args) {
        String user需求 = "帮我生成一段Java冒泡排序代码";
        // 1. Agent自主规划，决定调用的工具
        String toolPlan = planTool(user需求);
        System.out.println("Agent规划结果：" + toolPlan);
        // 2. 执行工具，获取结果
        String toolResult = executeTool(toolPlan);
        // 3. 调用LLM，整理结果并返回给用户（省略LLM调用逻辑）
        System.out.println("Agent最终输出：" + toolResult);
    }
}

9. 会话内存（Session Memory）

定义：会话内存是存储用户与LLM对话历史的机制，让LLM能“记住”之前的对话内容，实现上下文连贯的交互。对Java开发者而言，会话内存通常用List或Map存储，每次调用LLM时，将对话历史拼接进Prompt，提升交互体验。

Java极简示例（会话内存实现）：

import java.util.ArrayList;
import java.util.List;

public class SessionMemoryDemo {
    // 存储会话历史（用户消息+LLM回复）
    private static List<String> sessionMemory = new ArrayList<>();
    
    // 新增对话内容到会话内存
    private static void addToMemory(String role, String content) {
        sessionMemory.add(role + "：" + content);
    }
    
    // 生成带会话历史的Prompt
    private static String generatePromptWithMemory(String newQuestion) {
        // 拼接会话历史
        StringBuilder prompt = new StringBuilder();
        for (String msg : sessionMemory) {
            prompt.append(msg).append("\n");
        }
        prompt.append("用户：").append(newQuestion);
        return prompt.toString();
    }
    
    public static void main(String[] args) {
        // 第一轮对话
        String firstQuestion = "什么是LLM？";
        addToMemory("用户", firstQuestion);
        String firstAnswer = "LLM是大语言模型，能理解和生成人类语言。"; // 模拟LLM回复
        addToMemory("LLM", firstAnswer);
        
        // 第二轮对话（带上下文）
        String secondQuestion = "它和Java有什么关系？";
        String prompt = generatePromptWithMemory(secondQuestion);
        System.out.println("带会话历史的Prompt：" + prompt);
        // 调用LLM生成回答，会基于上一轮的内容（省略LLM调用逻辑）
    }
}

10. 流式输出（Stream Output）

定义：流式输出是LLM分批次返回生成结果的方式，而非一次性返回完整内容，类似“打字机”效果，能提升用户交互体验，避免长时间等待。对Java开发者而言，需通过异步回调或流处理方式接收LLM的流式响应。

Java极简示例（LLM流式输出）：

import com.openai.OpenAiClient;
import com.openai.models.ChatCompletionRequest;
import com.openai.models.ChatMessage;
import com.openai.models.ChatMessageRole;

import java.util.List;

public class StreamOutputDemo {
    public static void main(String[] args) {
        OpenAiClient client = OpenAiClient.builder()
                .apiKey("你的API_KEY")
                .build();
        // 构造流式调用请求
        ChatCompletionRequest request = ChatCompletionRequest.builder()
                .model("gpt-3.5-turbo")
                .messages(List.of(new ChatMessage(ChatMessageRole.USER, "用Java解释流式输出")))
                .stream(true) // 开启流式输出
                .build();
        // 接收流式响应，逐段打印
        client.chatCompletions().createStream(request)
                .doOnNext(response -> {
                    // 逐段获取生成的内容
                    String content = response.getChoices().get(0).getMessage().getContent();
                    if (content != null) {
                        System.out.print(content); // 不换行，模拟打字机效果
                    }
                })
                .blockLast(); // 等待流结束
    }
}

二、核心术语关联链路（Java视角）

以上10个术语并非孤立存在，而是构成了Java大模型开发的完整链路，用一句话总结：Java开发者通过Prompt指令，调用LLM（核心），借助Token控制成本，通过Embedding将文本转换为向量，存储到向量数据库中，通过RAG技术检索精准信息，结合Tool Calling调用Java业务工具，由Agent实现自主规划，通过会话内存保持上下文连贯，最终以流式输出提升用户体验。

📌 小提示：觉得这条链路有帮助的话，点赞收藏，后续我会更新基于这条链路的Java大模型完整项目实战～

三、常见误区汇总（避坑必看）

  1. 混淆Token与字符数：Token包含标点、空格、换行，需提前计算，避免超出模型Token限制；
  2. 认为LLM能直接执行Java代码：LLM仅能生成代码，需通过Java程序编译执行，或通过Tool Calling调用代码执行工具；
  3. 忽视Embedding的向量维度：不同模型生成的Embedding维度不同（如text-embedding-ada-002是1536维），需与向量数据库的维度匹配；
  4. 将Agent等同于Tool Calling：Agent具备自主规划能力，而Tool Calling仅能执行指定工具，前者是后者的高级形态；
  5. 会话内存无限制存储：对话历史过多会导致Token超标，需定期清理或截取核心内容。

四、结尾总结

本文为Java开发者拆解了大模型开发的10个核心术语，每个术语均配套极简Java代码示例，梳理了术语间的关联链路，纠正了入门常见误区，帮助Java开发者快速入门大模型开发。大模型与Java的融合是未来的重要趋势，掌握这些核心术语，能为后续开发大模型应用、实现业务集成打下坚实基础。

# RAG # AIGC
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

彻底读懂Claude Code动态工作流，让AI自己写脚本调度复杂任务

avatar AI编程社区
cover

无 Root 权限搞定！远程服务器配置 Claude Code 中转教程（终端/插件）

avatar AI编程社区
cover

打破AI模型内卷！Loop与Harness工程，才是Agent能力的真正天花板

avatar AI编程社区