langchain4j和openai都可以实现ai功能，侧重点不同，定制化程度高就用langchain4j。

版本选择：
jdk17
langchain4j # 0.34.0，要求boot3.x以上，最好3.2以上
springboot # 3.3.5，和上述langchain4j的版本要求匹配

langchain4j

引入依赖

属性标签里面添加版本：
<langchain4j.version>0.34.0</langchain4j.version>

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

        <!-- LangChain4j 对 Spring Boot 的自动装配支持 (可选，但推荐) -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-autoconfigure</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <!-- 如果你使用 OpenAI 模型，添加对应的 Model 连接器 -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

配置文件

注：和springai的配置有些区别。

# LangChain4j 官方支持的 OpenAI 兼容模式配置前缀
langchain4j:
  open-ai:
    chat-model:
      base-url: https://dashscope.aliyuncs.com/compatible-mode # 百炼兼容模式地址
      api-key: ${AI_DASHSCOPE_API_KEY} # 读取环境变量
      model-name: qwen-max # 模型名称
      temperature: 0.3 # 温度参数

LangChain4jConfig配置类

主要就是为了装配ChatLanguageModel，类似于数据库的session。
按道理应该会自动装配，实测报错了，所以手写了个配置类。

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

@Configuration
public class LangChain4jConfig {


    @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;

    @Bean
    public ChatLanguageModel chatLanguageModel() {
        // 1. 请替换为你自己的 OpenAI API Key
        // 2. 如果你使用的是国内的反向代理（如阿里云百炼、Azure等），请修改 baseUrl
        return OpenAiChatModel.builder()
                .apiKey(apiKey)
                .baseUrl(baseUrl) // 如果是国内代理，请修改这里的地址
                .modelName(modelName)
                .build();
    }
}

controller代码

package com.example.demo.web;

import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.request.ChatRequest;
import dev.langchain4j.model.chat.response.ChatResponse;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Collections;
import java.util.Map;

@RestController
@RequestMapping("/api")
public class LangChain4jController {


    // 注入 LangChain4j 的核心对话模型接口
    private final ChatLanguageModel chatLanguageModel;


    // 通过构造器注入（Spring Boot 会自动装配你在配置文件中配置的模型）
    public LangChain4jController(ChatLanguageModel chatLanguageModel) {
        this.chatLanguageModel = chatLanguageModel;
    }

    /**
     * POST 请求：/api/langchain4j/chat
     */
    @PostMapping("/langchain4j/chat")
    public ResponseEntity<String> chat(@RequestBody Map<String, String> request) {
        try {
            String message = request.getOrDefault("message", "你好");
            // 调用统一的内部处理方法
            String answer = processChat(message);
            return ResponseEntity.ok(answer);
        } catch (Exception e) {
            return ResponseEntity.internalServerError().body("Error: " + e.getMessage());
        }
    }

    /**
     * GET 请求：/api/langchain4j/chat?message=xxx
     */
    @GetMapping("/langchain4j/chat")
    public ResponseEntity<String> chatGet(@RequestParam String message) {
        try {
            // 调用统一的内部处理方法
            String answer = processChat(message);
            return ResponseEntity.ok(answer);
        } catch (Exception e) {
            return ResponseEntity.internalServerError().body("Error: " + e.getMessage());
        }
    }

    /**
     * 统一使用 ChatRequest 处理聊天逻辑
     */
    private String processChat(String message) {
        // 1. 将字符串封装为 UserMessage
        ChatMessage userMessage = UserMessage.from(message);

        // 2. 构建 ChatRequest
        ChatRequest chatRequest = ChatRequest.builder()
                .messages(Collections.singletonList(userMessage))
                // 未来如果需要自定义参数，可在此处添加：
                // .parameters(ChatRequestParameters.builder().temperature(0.7).build())
                .build();

        // 3. 调用模型，获取 ChatResponse
        ChatResponse chatResponse = chatLanguageModel.chat(chatRequest);

        // 4. 从响应中提取 AI 的回复文本
        return chatResponse.aiMessage().text();
    }
}

tools

定义工具类

import dev.langchain4j.agent.tool.Tool;
import org.springframework.stereotype.Component;

@Component
public class AssistantTools {

    @Tool("查询指定城市的当前天气和温度")
    public String getWeather(String city) {
        // 实际业务中这里会调用真实的天气 API
        return city + "当前天气晴，气温 28℃";
    }

    @Tool("查询用户今天的日程安排")
    public String getSchedule(String date) {
        // 实际业务中这里会查询数据库
        if ("今天".equals(date)) {
            return "14:00 参加产品需求评审会议，16:00 与研发团队同步进度";
        }
        return "今天暂无其他安排";
    }
}

定义AiAgentConfig

@Configuration
public class AiAgentConfig {

    // 定义一个 AI 助理的接口（LangChain4j 会自动实现这个接口）
    public interface SmartAssistant {
        String chat(String userMessage);
    }

    @Bean
    public SmartAssistant smartAssistant(ChatLanguageModel chatLanguageModel, AssistantTools tools) {
        return AiServices.builder(SmartAssistant.class)
                .chatLanguageModel(chatLanguageModel)
                .tools(tools) // 将包含动作的 Tools 注入给 AI
                .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
                .build();
    }
}

controller中引入

注入：
@Autowired
private AiAgentConfig.SmartAssistant smartAssistant;

具体方法：
@PostMapping("/langchain4j/agent")
    public String chat(@RequestBody String message) {
        return smartAssistant.chat(message);
    }

实测果然实现了类似skill的功能。