AI大模型实用(三)Java快速实现智能体整理(Springboot+LangChain4j)

目录

[1.1 简介](#1.1 简介)

[1.2 示例](#1.2 示例)

[步骤一： 添加pom](#步骤一： 添加pom)

步骤二：配置

步骤三：流式输出

[步骤四： 正常输出](#步骤四： 正常输出)

[步骤五： 【类似函数调用】AI Service接口](#步骤五： 【类似函数调用】AI Service接口)

[1.3 调试问题](#1.3 调试问题)

[问题1： ClassNotFoundException: dev.langchain4j.exception.IllegalConfigurationException](#问题1： ClassNotFoundException: dev.langchain4j.exception.IllegalConfigurationException)

[问题2： overriding is disabled](#问题2： overriding is disabled)

[问题3 ：dev.langchain4j.exception.IllegalConfigurationException](#问题3 ：dev.langchain4j.exception.IllegalConfigurationException)

[1.4 langchain4j与springAI对比](#1.4 langchain4j与springAI对比)

---

1.1 简介

一个基于 Java 的库，旨在简化自然语言处理（NLP）和大型语言模型（LLM）的集成；

提供了大量现成的组件（文档加载器、工具、链），用于构建AI应用，是目前Java生态中最接近Python LangChain成熟度的选择。

1.2 示例

步骤一： 添加pom

<!-- https://mvnrepository.com/artifact/dev.langchain4j/langchain4j -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
            <version>1.9.1</version>
        </dependency>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-core</artifactId>
            <version>1.9.1</version>
        </dependency>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>
<!--        导入响应式编程依赖包-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>

步骤二：配置

langchain4j.open-ai.chat-model.api-key=你的deepseekkey
langchain4j.open-ai.chat-model.model-name=deepseek-chat
langchain4j.open-ai.chat-model.base-url=https://api.deepseek.com
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true

如果没有key:

langchain4j.open-ai.chat-model.api-key=demo

langchain4j.open-ai.chat-model.model-name=gpt-4o-mini

langchain4j.open-ai.chat-model.base-url=http://langchain4j.dev/demo/openai/v1

步骤三：流式输出

package com.ai.LangChain4j;

import dev.langchain4j.model.chat.StreamingChatModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

//创建流式聊天模型配置
@Configuration
public class Langchain4jStreamingChatModelConfig {
    @Value("${langchain4j.open-ai.chat-model.api-key}")
    private String apiKey;

    @Value("${langchain4j.open-ai.chat-model.base-url}")
    private String baseUrl;

    @Value("${langchain4j.open-ai.chat-model.model-name}")
    private String modelName;

    @Value("${langchain4j.open-ai.chat-model.log-requests}")
    private Boolean logRequests;

    @Value("${langchain4j.open-ai.chat-model.log-responses}")
    private Boolean logResponses;

    @Bean("langchain4jStreamingChatModel")
    public StreamingChatModel streamingChatModel() {
        Map<String,String> map = new HashMap<>();
        map.put("Content-Type","application/json");
        map.put("charset","utf-8");
        return OpenAiStreamingChatModel.builder()
                .baseUrl(baseUrl)
                .apiKey(apiKey)
                .modelName(modelName)        //使用的模型名称
                .temperature(0.7)           // 控制回答的随机性（0-1，越高越随机）
                .maxTokens(1000)           // 单次回答的最大token数
                .logRequests(logRequests)   // 记录请求日志
                .logResponses(logResponses) // 记录响应日志
                .returnThinking(true)       // 是否返回AI的思考过程
//                .customHeaders(map)
                .build();
    }
}




@Resource(name = "langchain4jStreamingChatModel")
private OpenAiStreamingChatModel streamingChatModel;


@RequestMapping(value = "/chatstream")
        public Flux<String> chatstream(@RequestParam("message") String prompt)
        {
            return Flux.create(emitter -> {
                streamingChatModel.chat(prompt, new StreamingChatResponseHandler()
                {
                    @Override
                    public void onPartialResponse(String partialResponse)
                    {
                        emitter.next(partialResponse);
                    }

                    @Override
                    public void onCompleteResponse(ChatResponse chatResponse) {
                        emitter.complete();
                    }
                    @Override
                    public void onError(Throwable throwable)
                    {
                        emitter.error(throwable);
                    }
                });
            });
        }

参考：https://www.cnblogs.com/timothy020/p/19043509

步骤四： 正常输出

@Autowired
    private OpenAiChatModel model;


@RequestMapping("/chat")
    public String chat(String message) {
        return model.chat(message);
    }

步骤五： 【类似函数调用】AI Service接口

package com.ai.LangChain4j;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.spring.AiService;
import dev.langchain4j.service.UserMessage;
/**
 * AI Service接口 :可把它看作标准 Spring Boot的 @Service，但带有 AI 功能。
 *
 * 当应用程序启动时，LangChain4j 启动器将扫描类路径并找到所有带有 @AiService 注解的接口。对于每个找到的 AI 服务，它将使用应用程序上下文中的所有 LangChain4j 组件创建此接口的实现，并将其注册为一个 bean
 *
 * 最大限度的调用函数工具:@UserMessage 我们通过提示词，让大模型尽量考虑调用我们的函数工具
 */
@AiService
interface Assistant {
    @UserMessage("针对提出的问题：{{it}}，请尽量调用已有的函数工具")
    @SystemMessage("You are a polite assistant")
    String chat(String userMessage);
}







package com.ai.LangChain4j;

import dev.langchain4j.agent.tool.Tool;

/** 定义工具类（类似函数调用）
 * @Tool用于对函数进行功能描述
 * 描述的越清楚，大模型越容易考虑是否需要使用函数工具
 *工具可以是任何东西：网页搜索、外部API调用、或执行一段特定代码等
 *
 *
 */
public class CalculatorTool {
    @Tool("计算字符串的长度")
    int stringLength(String s) {
        System.out.println("Called stringLength with s='" + s + "'");
        return s.length();
    }

    @Tool("计算两个整数的和")
    int add(int a, int b) {
        System.out.println("Called add with a=" + a + ", b=" + b);
        return a + b;
    }

    @Tool("计算整数的平方根")
    double sqrt(int x) {
        System.out.println("Called sqrt with x=" + x);
        return Math.sqrt(x);
    }

}






@Autowired
    private ChatModel chatModel;
 @Autowired
    Assistant assistant;

@GetMapping("/assistantchat")
    public String assistantchat(String message) {

        assistant = AiServices.builder(Assistant.class)
                .chatModel(chatModel)
                .tools(new CalculatorTool())
                .build();
        return assistant.chat(message);
    }

注： 运行时有日志

    @RequestMapping("/chat")
    public String chat(String message) {
        return model.chat(message);
    }

运行结果：

@GetMapping("/assistantchat")
    public String assistantchat(String message) {

        assistant = AiServices.builder(Assistant.class)
                .chatModel(chatModel)
                .tools(new CalculatorTool())
                .build();
        return assistant.chat(message);
    }

运行结果：

参考：

https://blog.csdn.net/matrixlzp/article/details/150610135

https://blog.csdn.net/m0_71741473/article/details/148379520

https://cloud.tencent.com/developer/article/2512470

1.3 调试问题

问题1： ClassNotFoundException: dev.langchain4j.exception.IllegalConfigurationException

解决： 检查

application.properties的配置

langchain4j.open-ai.chat-model.api-key=demo
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini
langchain4j.open-ai.chat-model.base-url=http://langchain4j.dev/demo/openai/v1

注： 如果你暂时没有密钥，也可以使用 LangChain4j 提供的演示密钥(同上)，这个密钥是免费的，有使用配额限制，且仅限于 gpt-4o-mini 模型

注： 如果已经有密钥，直接替换即可。

问题2： overriding is disabled

The bean 'openAiChatModel', defined in class path resource [org/springframework/ai/autoconfigure/openai/OpenAiAutoConfiguration.class], could not be registered. A bean with that name has already been defined in class path resource [dev/langchain4j/openai/spring/AutoConfig.class] and overriding is disabled.

解决：

去掉langchain4j的openapi相关的依赖或者去掉SpringAI的openapi相关的依赖

<!--        &lt;!&ndash; LangChain4j OpenAI 支持（用于兼容 OpenAI 接口的模型，如 GPT 或阿里云百炼） &ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>dev.langchain4j</groupId>-->
<!--            <artifactId>langchain4j-open-ai</artifactId>-->
<!--            <version>1.9.1</version>-->
<!--        </dependency>-->

<!--        <dependency>-->
<!--            <groupId>dev.langchain4j</groupId>-->
<!--            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>-->
<!--            <version>1.9.1-beta17</version>-->
<!--        </dependency>-->

问题3 ：dev.langchain4j.exception.IllegalConfigurationException

解决： 该问题是langchain4j-spring-boot-starter版本兼容问题。 可以对应修改和langchain4j生态兼容的版本。例如
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>1.9.1-beta17</version>
</dependency>

1.4 langchain4j与springAI对比

核心功能对比

1. ‌设计理念与定位‌：
   • Spring AI 由 Spring 官方团队维护，核心目标是简化 AI 模型集成，提供统一 API 调用（如 OpenAI、Azure OpenAI），降低开发门槛，尤其适合已使用 Spring 生态的项目。‌‌
   • LangChain4j 是 LangChain 的 Java 实现，专注于模块化设计，支持智能 Agent、链式调用、记忆管理等高级功能，灵活性更高，但需要开发者手动组装组件。‌‌
2. ‌高级功能支持‌：
   • ‌多步骤推理与 Agent 管理‌：LangChain4j 内置 Agent 框架，支持复杂工作流编排（如动态工具调用、多条件决策），而 Spring AI 需开发者自行实现逻辑。‌‌
   • ‌记忆与上下文管理‌：LangChain4j 提供多样化记忆存储方案（如会话记忆、长期记忆），Spring AI 需手动管理对话状态。‌‌
   • ‌工具集成‌：LangChain4j 支持直接定义和调用外部工具（如天气查询、计算器），Spring AI 需额外处理函数调用。‌‌
3. ‌RAG（检索增强生成）支持‌：LangChain4j 提供文本加载、解析、分割等完整工具链，Spring AI 的 RAG 功能相对基础

注意：

可以与 Spring Boot 等整合（langchain4j-spring 模块），但核心是一个纯 Java 库，需要手工 wiring 多数部分。

• 使用 Spring AI 的典型用途：

  • 在已有 Spring Boot 微服务中嵌入 Chat 或 文本生成功能，例如客服机器人、内部文档助手。

  • 快速开发 embedding 搜索 + AI 文本摘要 + 图像生成业务。

  • 利用 Spring 的现有安全配置 /配置中心 /监控系统，保持统一架构。

• 使用 LangChain4j 的典型用途：

  • 构建需要 Agent 调度、工具调用、Memory 管理的智能体。例如"用户输入 → 检索数据库 → 调用外部 API → 合成响应 → 写入日志"这种多步骤流程。

  • 构建自定义 RAG 服务：可插入自定义向量数据库、检索策略、重排序逻辑等。

  • 希望在 Java 应用中迁移或复制 LangChain Python 的工作流逻辑。

参考：

https://www.cnblogs.com/duanxz/p/19088542

https://cloud.tencent.com/developer/article/2531640