2026年，AI智能体开发不再是Python的专属领域。本文将带你通过3小时的时间，利用LangChain4j、Spring AI等框架，从零开始实现你的第一个Java AI智能体。内容涵盖环境准备、项目创建、Hello World示例、工具调用、任务执行Agent构建、记忆功能实现以及常见问题解答，适合所有希望了解AI智能体开发的Java开发者。

这个教程里的所有代码都经过验证，依赖版本明确，环境配置详细，还附带测试验证步骤。

学完后你能：

• 用 Java 编写 AI 智能体
• 让 Agent 调用外部工具
• 实现对话、查询、执行任务

一、环境准备

---

1.1 必需环境

# Java 版本（要求 17+）
java -version

# Maven 版本（要求 3.6+）
mvn -version

1.2 API Key 准备

本教程使用 OpenAI API，也可替换为其他模型。

获取 OpenAI API Key：

1. 访问 https://platform.openai.com/api-keys[1]

2. 创建 API Key

3. 保存 Key（格式：sk-xxxxxxxx）

国内替代方案：

• 通义千问：https://dashscope.console.aliyun.com/[2]
• 文心一言：https://cloud.baidu.com/product/wenxinworkshop[3]
• Kimi：https://platform.moonshot.cn/[4]

二、创建项目

2.1 初始化 Maven 项目

# 创建项目目录
mkdir java-agent-tutorial
cd java-agent-tutorial

# 初始化 Maven 项目
mvn archetype:generate /
  -DgroupId=com.example /
  -DartifactId=java-agent-tutorial /
  -DarchetypeArtifactId=maven-archetype-quickstart /
  -DarchetypeVersion=1.4 /
  -DinteractiveMode=false

2.2 配置 pom.xml

完整的 pom.xml 配置：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>java-agent-tutorial</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <langchain4j.version>0.35.0</langchain4j.version>
    </properties>

    <dependencies>
        <!-- LangChain4j 核心依赖 -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <!-- OpenAI 集成 -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <!-- 日志 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>2.0.9</version>
        </dependency>

        <!-- JUnit 测试 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.10.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

验证依赖下载：

mvn dependency:resolve

看到 BUILD SUCCESS 即可继续。

三、第一个 Agent：Hello World

---

3.1 编写第一个 Agent

src/main/java/com/example/HelloAgent.java：

package com.example;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

importstatic dev.langchain4j.model.openai.OpenAiChatModelName.GPT_3_5_TURBO;

/
 * 第一个 Agent 示例：简单的对话助手
 */
public class HelloAgent {

    // 定义 Agent 接口
    interfaceAssistant {
        String chat(String userMessage);
    }

    public static void main(String[] args) {
        // 1. 创建聊天模型
        ChatLanguage Model model= OpenAiChatModel.builder()
            .apiKey("OPENAI_API_KEY")
            .modelName("OPENAI_MODEL_NAME")          .baseUrl("OPENAI_API_URL")            .build();

        // 2. 创建 AI 服务
        Assistant assistant = AiServices.builder(Assistant.class)
            .chatLanguageModel(model)
            .build();

        // 3. 与 Agent 对话
        Stringresponse= assistant.chat("你好，请用一句话介绍你自己");
        System.out.println("Agent: " + response);
    }
}

3.2 运行测试

# 编译
mvn clean compile

# 运行
mvn exec:java -Dexec.mainClass="com.example.HelloAgent"

预期输出：

四、让 Agent 调用工具

---

Agent 的核心能力是调用工具。LangChain4j 通过 @Tool 注解实现这一功能。

4.1 创建天气查询工具

src/main/java/com/example/WeatherTool.java：

package com.example;

import dev.langchain4j.agent.tool.Tool;

/
 * 天气查询工具
 * 模拟天气 API 调用
 */
publicclassWeatherTool {

    @Tool("查询指定城市的天气")
    public String getWeather(String city) {
        // 实际项目中调用天气 API
        // 这里模拟返回
        returnswitch (city.toLowerCase()) {
            case"北京" -> "北京，晴，温度：25°C，湿度：40%";
            case"上海" -> "上海，小雨，温度：22°C，湿度：70%";
            case"广州" -> "广州，多云，温度：28°C，湿度：60%";
            case"深圳" -> "深圳，晴，温度：29°C，湿度：55%";
            default -> city + "，天气数据暂不可用";
        };
    }
}

4.2 创建计算器工具

src/main/java/com/example/CalculatorTool.java：

package com.example;

import dev.langchain4j.agent.tool.Tool;

/
 * 计算器工具
 */
publicclassCalculatorTool {

    @Tool("两个数相加")
    publicdoubleadd(double a, double b) {
        return a + b;
    }

    @Tool("两个数相减")
    publicdoublesubtract(double a, double b) {
        return a - b;
    }

    @Tool("两个数相乘")
    publicdoublemultiply(double a, double b) {
        return a * b;
    }

    @Tool("两个数相除")
    publicdoubledivide(double a, double b) {
        if (b == 0) {
            return Double.NaN;
        }
        return a / b;
    }
}

4.3 集成工具到 Agent

src/main/java/com/example/ToolAgent.java：

package com.example;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

importstatic dev.langchain4j.model.openai.OpenAiChatModelName.GPT_3_5_TURBO;

/
 * 带工具的 Agent 示例
 */
publicclassToolAgent {

    // 定义 Agent 接口
    interfaceAssistant {
        String chat(String userMessage);
    }

    publicstaticvoidmain(String[] args) {
        // 1. 创建聊天模型
        ChatLanguage Model model=OpenAiChatModel.builder()            .apiKey("OPENAI_API_KEY")
            .modelName("OPENAI_MODEL_NAME")          .baseUrl("OPENAI_API_URL")            .build();

        // 2. 创建工具实例
        WeatherTool weatherTool= new WeatherTool();
        CalculatorTool calculatorTool= new CalculatorTool();

        // 3. 创建 AI 服务（注册工具）
        Assistant assistant= AiServices.builder(Assistant.class)
            .chatLanguageModel(model)
            .tools(weatherTool, calculatorTool)
            .build();

        // 4. 测试对话
        System.out.println("=== 测试天气查询 ===");
        String response1= assistant.chat("北京今天天气怎么样？");
        System.out.println("Agent: " + response1);

        System.out.println("/n=== 测试计算 ===");
        String response2= assistant.chat("123 乘以 456 等于多少？");
        System.out.println("Agent: " + response2);

        System.out.println("/n=== 测试混合任务 ===");
        String response3= assistant.chat("上海和广州的天气哪个更好？");
        System.out.println("Agent: " + response3);
    }
}

4.4 运行测试

mvn exec:java -Dexec.mainClass="com.example.ToolAgent"

预期输出：

=== 测试天气查询 ===
Agent: 北京今天天气晴朗，温度 25°C，湿度 40%，适合外出活动。

=== 测试计算 ===
Agent: 123 乘以 456 等于 56088。

=== 测试混合任务 ===
Agent: 根据天气数据：
- 上海：小雨，22°C，湿度 70%
- 广州：多云，28°C，湿度 60%

广州的天气更好，温度适宜且没有降雨。

到这里，你已经掌握了如何让 Agent 调用工具。接下来我们构建一个更实用的任务执行 Agent。

五、实战：构建任务执行 Agent

---

5.1 创建文件操作工具

src/main/java/com/example/FileTool.java：

package com.example;

import dev.langchain4j.agent.tool.Tool;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;


import java.util.List;
import java.util.stream.Collectors;

/

 * 文件操作工具
   */
   publicclassFileTool {

    privatefinalStringworkingDir= System.getProperty("java.io.tmpdir");

    @Tool("读取文件内容")
    public String readFile(String filename) {
        try {
            Pathpath= Paths.get(workingDir, filename);
            return Files.readString(path);
        } catch (IOException e) {
            return"错误：无法读取文件 - " + e.getMessage();
        }
    }

    @Tool("写入文件内容")
    public String writeFile(String filename, String content) {
        try {
            Pathpath= Paths.get(workingDir, filename);
            Files.writeString(path, content);
            return"成功：文件已写入 " + path.toAbsolutePath();
        } catch (IOException e) {
            return"错误：无法写入文件 - " + e.getMessage();
        }
    }

    @Tool("列出目录中的文件")
    public String listFiles() {
        try {
            Pathpath= Paths.get(workingDir);
            return Files.list(path)
                .filter(Files::isRegularFile)
                .map(p -> p.getFileName().toString())
                .limit(20)
                .collect(Collectors.joining("/n"));
        } catch (IOException e) {
            return"错误：无法列出文件 - " + e.getMessage();
        }
    }
}

5.2 创建任务执行 Agent

src/main/java/com/example/TaskAgent.java：

package com.example;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

import static dev.langchain4j.model.openai.OpenAiChatModelName.GPT_3_5_TURBO;

/

 * 任务执行 Agent
   */
   public class TaskAgent {

    interface Assistant {
        String chat(String userMessage);
    }

    publicstaticvoidmain(String[] args) {
        // 1. 创建模型
ChatLanguage Model model= OpenAiChatModel.builder()
            .apiKey("OPENAI_API_KEY")
            .modelName("OPENAI_MODEL_NAME")          .baseUrl("OPENAI_API_URL")            .build();

        // 2. 创建工具
        FileTool fileTool= new FileTool();
        CalculatorTool calculatorTool= new CalculatorTool();

        // 3. 创建 Agent
        Assistant assistant= AiServices.builder(Assistant.class)
            .chatLanguageModel(model)
            .tools(fileTool, calculatorTool)
            .build();

        // 4. 测试任务
        System.out.println("=== 测试 1：创建文件 ===");
        String response1= assistant.chat(
            "创建一个文件 test.txt，内容是：Hello, AI Agent!"
        );
        System.out.println("Agent: " + response1);

        System.out.println("/n=== 测试 2：读取文件 ===");
        String response2= assistant.chat("读取 test.txt 的内容");
        System.out.println("Agent: " + response2);

        System.out.println("/n=== 测试 3：计算并保存 ===");
        String response3= assistant.chat(
            "计算 256 乘以 128 的结果，保存到 result.txt"
        );
        System.out.println("Agent: " + response3);
    }
}

5.3 运行测试

mvn exec:java -Dexec.mainClass="com.example.TaskAgent"

预期输出：

=== 测试 1：创建文件 ===
Agent: 已成功创建文件 test.txt，内容为：Hello, AI Agent!

=== 测试 2：读取文件 ===
Agent: test.txt 的内容是：Hello, AI Agent!

=== 测试 3：计算并保存 ===
Agent: 256 乘以 128 等于 32768，结果已保存到 result.txt

验证生成的文件：

# 查看临时目录

ls -la /tmp/test.txt /tmp/result.txt

# 查看内容

cat /tmp/test.txt
cat /tmp/result.txt

六、使用记忆功能

---

前面的 Agent 每次对话都是独立的，无法记住之前的内容。加上记忆功能后，Agent 就能进行多轮对话。

6.1 创建带记忆的 Agent

src/main/java/com/example/MemoryAgent.java：

package com.example;

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

importstatic dev.langchain4j.model.openai.OpenAiChatModelName.GPT_3_5_TURBO;

/

 * 带记忆功能的 Agent
   */
   publicclassMemoryAgent {

    interfaceAssistant {
        String chat(String userMessage);
    }

    publicstaticvoidmain(String[] args) {
        // 1. 创建模型
        ChatLanguageModelmodel= OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName(GPT_3_5_TURBO)
            .build();

        // 2. 创建聊天记忆（保留最近 10 条消息）
        ChatMemorychatMemory= MessageWindowChatMemory.withMaxMessages(10);

        // 3. 创建 Agent（启用记忆）
        Assistantassistant= AiServices.builder(Assistant.class)
            .chatLanguageModel(model)
            .chatMemory(chatMemory)
            .build();

        // 4. 多轮对话测试
        System.out.println("=== 第一轮 ===");
        Stringresponse1= assistant.chat("我叫小明，今年 25 岁");
        System.out.println("Agent: " + response1);

        System.out.println("/n=== 第二轮 ===");
        Stringresponse2= assistant.chat("我喜欢编程");
        System.out.println("Agent: " + response2);

        System.out.println("/n=== 第三轮（测试记忆）===");
        Stringresponse3= assistant.chat("我叫什么名字？今年多大？");
        System.out.println("Agent: " + response3);
    }
}

6.2 运行测试

mvn exec:java -Dexec.mainClass="com.example.MemoryAgent"

预期输出：

=== 第一轮 ===
Agent: 你好小明，很高兴认识你！25 岁是个很好的年纪。

=== 第二轮 ===
Agent: 编程是个很棒的爱好！你平时喜欢用什么编程语言？

=== 第三轮（测试记忆）===
Agent: 你叫小明，今年 25 岁。

---

七、常见问题

---

7.1 API Key 无效

错误信息：

401 Unauthorized - Invalid API key

解决方案：

检查环境变量是否正确设置：

echo $OPENAI_API_KEY

确保没有多余空格，正确格式：

export OPENAI_API_KEY=sk-xxx

7.2 依赖下载失败

错误信息：

Could not resolve dependencies

解决方案：

清理 Maven 缓存后重新下载：

rm -rf ~/.m2/repository/dev/langchain4j
mvn clean dependency:resolve -U

7.3 工具调用失败

错误信息：

Tool execution failed

解决方案：

1. 检查 @Tool 注解是否正确

2. 确保工具方法是 public 的

3. 检查参数类型是否匹配

7.4 使用国内模型

替换为通义千问：

<!-- pom.xml 添加依赖 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-dashscope</artifactId>
    <version>0.35.0</version>
</dependency>

// Java 代码替换模型
import dev.langchain4j.model.dashscope.QwenChatModel;

ChatLanguageModel model = QwenChatModel.builder()
    .apiKey(System.getenv("DASHSCOPE_API_KEY"))
    .modelName("qwen-plus")
    .build();

---

八、进阶学习

---

8.1 推荐资源

• LangChain4j 官方文档：https://docs.langchain4j.dev/[5]
• GitHub 仓库：https://github.com/langchain4j/langchain4j[6]
• 示例项目：https://github.com/langchain4j/langchain4j-examples[7]

8.2 进阶主题

RAG（检索增强生成）

• 连接向量数据库
• 实现知识库问答

多 Agent 协作

• 多个 Agent 分工合作
• 实现复杂任务

Agent 持久化

• 保存对话历史
• 跨会话记忆

部署上线

• 打包成 Docker 镜像
• 部署到云服务器

---

总结

Java 开发 AI 智能体的门槛已经很低，LangChain4j 等框架让 Java 开发者能快速上手。关键是动手实践。

建议的学习路径：

1. 跑通本教程所有示例

2. 修改工具类，接入真实 API

3. 构建自己的 Agent 应用

遇到问题时：

• 检查 Java 版本（17+）

• 确认 API Key 有效

• 查看 LangChain4j 官方文档

  最后

如果说程序员已经是高薪职业，那么干AI的程序员，就是高薪中的高薪。

现在的市场，已经用数据给程序员指明了方向：学AI大模型，就是冲刺高薪的最优解！

看着身边越来越多的同行转型大模型、拿到高薪offer，很多人心里都动了心，但真正的难题来了：零基础小白不知道从哪入门？有基础的程序员找不到系统学习路径？实战项目练手无门？面试不知道考什么？

别慌！今天就给大家整理了一份【2026年最新版】AI大模型免费学习资源包，覆盖从入门到实战、从理论到面试、从基础到进阶的全流程，所有资料均已整理归档，无冗余、无套路，免费分享给每一位想抓住AI风口的程序员和小白！

👇👇扫码免费领取全部内容👇👇

1、大模型系统化学习路线

2、大模型学习书籍&文档

3、AI大模型最新行业报告

4、大模型项目实战&配套源码

5、大模型大厂面试真题

四阶段精细化学习规划（附时间节点，可直接照做）

结合上述资源，给大家整理了一份可直接落地的四阶段学习规划，总时长约2个月，小白可循序渐进，程序员可根据自身基础调整节奏，高效掌握大模型核心能力，快速实现从“入门”到“能落地、能面试”的跨越。

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

👇👇扫码免费领取全部内容👇👇

6、这些资料真的有用吗？

这份资料由我和鲁为民博士(北京清华大学学士和美国加州理工学院博士)共同整理，现任上海殷泊信息科技CEO，其创立的MoPaaS云平台获Forrester全球’强劲表现者’认证，服务航天科工、国家电网等1000+企业，以第一作者在IEEE Transactions发表论文50+篇，获NASA JPL火星探测系统强化学习专利等35项中美专利。本套AI大模型课程由清华大学-加州理工双料博士、吴文俊人工智能奖得主鲁为民教授领衔研发。

资料内容涵盖了从入门到进阶的各类视频教程和实战项目，无论你是小白还是有些技术基础的技术人员，这份资料都绝对能帮助你提升薪资待遇，转行大模型岗位。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

https://mp.weixin.qq.com/s/2P64VRSHoOz31E2oAT_ZpQ