论坛 › Oracle › 【微服务】SpringBoot整合LangChain4j 操作AI大模子实战详解

钜形不锈钢水箱 发表于 2025-4-14 04:33:47

【微服务】SpringBoot整合LangChain4j 操作AI大模子实战详解

【微服务】SpringBoot整合LangChain4j 操作AI大模子实战详解

一、前言

随着人工智能技术的飞速发展，AI大模子已经在众多范畴展现出强大的本领，为业务拓展和商业价值提升带来了新的机会。SpringBoot作为一款广受接待的Java微服务框架，以其简洁、高效的特点深受开发者喜爱。而LangChain4j作为一款专注于AI大模子集成的开源库，为Java开发者提供了一种简单且高效的方式来接入和利用各种AI大模子。本文将详细介绍如何在SpringBoot中整合LangChain4j，实现对AI大模子的操作，资助读者快速上手并应用到实际项目中。
二、LangChain4j概述

（一）LangChain4j介绍

LangChain4j是一款基于Java的轻量级框架，专为Java开发者设计，旨在简化大型语言模子（LLMs）在Java应用中的集成。它借鉴了Python版LangChain的设计理念，提供了丰富的工具和组件，资助开发者快速构建基于LLMs的应用程序，如聊天机器人、问答体系、文本生成等。
（二）主要特点


[*]模块化架构：允许开发者根据需要选择和利用特定功能，如模子集成、数据加载、链式调用等。
[*]支持多种LLM提供商：如OpenAI、Hugging Face等，方便切换和集成差别模子。
[*]提供链式调勤奋能：允许将多个任务串联，如文本生成后主动进行情感分析。
[*]内置多种数据加载器和处置惩罚器：支持从差别泉源加载数据并进行预处置惩罚。
[*]提供丰富的API和扩展点：开发者可以自界说组件以满足特定需求。
（三）焦点组件

LangChain4j的焦点组件包括语言模子（Language Model）、记忆（Memory）、工具（Tool）等。此中，语言模子是焦点，负责生成文本；记忆用于存储对话历史，以便模子可以或许进行上下文相关的回答；工具则可以扩展模子的本领，例如进行搜索、调用API等。
（四）焦点优势


[*]简单易用：提供了简洁的API，方便开发者快速上手。
[*]灵活性高：支持多种语言模子和工具，可以根据需求灵活组合。
[*]安全性强：提供了API Key管理等功能，保障数据安全。
（五）焦点应用场景

LangChain4j适用于多种场景，包括但不限于：


[*]聊天机器人：通过对话本领实现智能客服、虚拟助手等。
[*]问答体系：结合知识库，提供准确的问答服务。
[*]文本生成：生成文章、故事、代码等。
三、SpringBoot整合LangChain4j

（一）前置预备


[*] 获取API Key

[*]如果利用OpenAI的模子，需要在OpenAI官网注册账号并获取API Key。
[*]将API Key存储在情况变量或配置文件中，制止直接写在代码里。

[*] 导入基础依赖

[*]在pom.xml文件中添加LangChain4j相关依赖。例如，利用OpenAI的模子时，需要添加以下依赖：<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>dev.langchain4j</groupId>
      <artifactId>langchain4j-core</artifactId>
      <version>最新版本号</version>
    </dependency>
    <dependency>
      <groupId>dev.langchain4j</groupId>
      <artifactId>langchain4j-open-ai</artifactId>
      <version>最新版本号</version>
    </dependency>
</dependencies>


[*] 添加配置文件

[*]在application.properties或application.yml文件中配置语言模子的关键参数。以OpenAI为例：langchain4j.openai.apiKey=你的OpenAI API Key


（二）对话本领利用

1. Low Level API利用

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

@Service
public class ChatService {
    private final ChatLanguageModel chatModel;

    public ChatService() {
      this.chatModel = new OpenAiChatModel();
    }

    public String chat(String userMessage) {
      return chatModel.generate(userMessage);
    }
}
2. High Level API利用

import dev.langchain4j.chain.ConversationalRetrievalChain;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;

@Service
public class ChatService {
    private final ChatLanguageModel model;

    public ChatService() {
      model = new OpenAiChatModel();
    }

    public String chat(String userMessage) {
      ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()
                .chatLanguageModel(model)
                .build();
      return chain.execute(userMessage);
    }
}
3. 设置角色

import dev.langchain4j.template.PromptTemplate;
import org.springframework.stereotype.Service;

@Service
public class PromptService {
    private final PromptTemplate promptTemplate = PromptTemplate.from(
            "你是一个{{role}}，请用专业的角度回答：{{question}}");

    private final ChatLanguageModel chatModel;

    public PromptService(ChatLanguageModel chatModel) {
      this.chatModel = chatModel;
    }

    public String getResponse(String role, String question) {
      String prompt = promptTemplate.apply(Parameters.from(
                "role", role,
                "question", question));
      return chatModel.generate(prompt);
    }
}
（三）会话记忆

1. Low Level API的实现

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

@Service
public class ChatService {
    private final ChatLanguageModel chatModel;
    private final MessageWindowChatMemory memory;

    public ChatService() {
      this.chatModel = new OpenAiChatModel();
      this.memory = MessageWindowChatMemory.builder()
                .maxMessages(50)
                .build();
    }

    public String chat(String userMessage) {
      memory.add(UserMessage.from(userMessage));
      String response = chatModel.generate(memory.messages());
      memory.add(AiMessage.from(response));
      return response;
    }
}
2. High Level API的实现

import dev.langchain4j.chain.ConversationalRetrievalChain;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;

@Service
public class ChatService {
    private final ChatLanguageModel model;
    private final MessageWindowChatMemory memory;

    public ChatService() {
      model = new OpenAiChatModel();
      memory = MessageWindowChatMemory.builder()
                .maxMessages(50)
                .build();
    }

    public String chat(String userMessage) {
      ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()
                .chatLanguageModel(model)
                .chatMemory(memory)
                .build();
      return chain.execute(userMessage);
    }
}
（四）Function Calling

1. 焦点概念

Function Calling允许模子调用外部函数来获取数据或执行操作。例如，模子可以调用一个搜索API来获取最新的信息。
2. 应用场景



[*]联网搜索：模子可以通过调用搜索API获取实时信息。
[*]调用外部API：例如调用天气API获取天气信息。
3. 案例代码

import dev.langchain4j.agent.Agent;
import dev.langchain4j.agent.AgentToolCall;
import dev.langchain4j.agent.AgentToolCallResult;
import dev.langchain4j.agent.ToolCall;
import dev.langchain4j.agent.ToolCallResult;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolRegistry;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;

@Service
public class FunctionCallingService {
    private final ChatLanguageModel model;
    private final ToolRegistry toolRegistry;

    public FunctionCallingService() {
      model = new OpenAiChatModel();
      toolRegistry = new ToolRegistry();
    }

    public String execute(String userMessage) {
      Agent agent = Agent.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .build();

      return agent.execute(userMessage);
    }

    @Tool(name = "search", description = "搜索信息")
    public String search(String query) {
      // 实现搜索逻辑，例如调用外部搜索API
      return "搜索结果：" + query;
    }

    @Tool(name = "weather", description = "获取天气信息")
    public String getWeather(String location) {
      // 实现获取天气信息的逻辑
      return "天气信息：" + location;
    }
}
（五）RAG（Retrieval-Augmented Generation）

1. 焦点概念

RAG是一种结合检索和生成的技术，通过检索相关文档来加强模子的生成本领。
2. 应用场景



[*]问答体系：结合知识库提供准确答案。
[*]文档辅助写作：根据文档内容生成相关内容。
3. 案例代码

import dev.langchain4j.chain.RetrievalAugmentedGenerationChain;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentLoader;
import dev.langchain4j.data.document.FileDocumentLoader;
import dev.langchain4j.data.segment.TextSegmenter;
import dev.langchain4j.data.segment.TextSegmenterFactory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.retrieval.Retriever;
import dev.langchain4j.retrieval.vectorstore.VectorStoreRetriever;
import dev.langchain4j.vectorstore.VectorStore;
import dev.langchain4j.vectorstore.VectorStoreFactory;

@Service
public class RagService {
    private final ChatLanguageModel model;
    private final Retriever retriever;

    public RagService() {
      model = new OpenAiChatModel();
      VectorStore vectorStore = VectorStoreFactory.create();
      retriever = new VectorStoreRetriever(vectorStore);
    }

    public String rag(String userMessage) {
      RetrievalAugmentedGenerationChain chain = RetrievalAugmentedGenerationChain.builder()
                .chatLanguageModel(model)
                .retriever(retriever)
                .build();
      return chain.execute(userMessage);
    }

    public void loadDocuments() {
      DocumentLoader documentLoader = new FileDocumentLoader("path/to/documents");
      List<Document> documents = documentLoader.load();
      TextSegmenter segmenter = TextSegmenterFactory.create();
      List<TextSegment> segments = segmenter.segment(documents);
      retriever.add(segments);
    }
}
（六）工具调用

1. 焦点概念

工具调用允许模子调用外部工具来完成任务，例如调用API、执行下令等。
2. 应用场景



[*]调用API：例如调用天气API获取天气信息。
[*]执行下令：例如调用体系下令执行操作。
3. 案例代码

import dev.langchain4j.agent.Agent;
import dev.langchain4j.agent.AgentToolCall;
import dev.langchain4j.agent.AgentToolCallResult;
import dev.langchain4j.agent.ToolCall;
import dev.langchain4j.agent.ToolCallResult;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolRegistry;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;

@Service
public class ToolCallingService {
    private final ChatLanguageModel model;
    private final ToolRegistry toolRegistry;

    public ToolCallingService() {
      model = new OpenAiChatModel();
      toolRegistry = new ToolRegistry();
    }

    public String execute(String userMessage) {
      Agent agent = Agent.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .build();

      return agent.execute(userMessage);
    }

    @Tool(name = "search", description = "搜索信息")
    public String search(String query) {
      // 实现搜索逻辑，例如调用外部搜索API
      return "搜索结果：" + query;
    }

    @Tool(name = "weather", description = "获取天气信息")
    public String getWeather(String location) {
      // 实现获取天气信息的逻辑
      return "天气信息：" + location;
    }
}
（七）自界说模子

1. 焦点概念

自界说模子允许开发者根据需求实现自己的语言模子，例如利用当地模子或自界说逻辑。
2. 应用场景



[*]利用当地模子：例如利用当地的Transformer模子。
[*]自界说逻辑：例如实现特定的文本生成逻辑。
3. 案例代码

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.ChatMessage;
import dev.langchain4j.model.chat.ChatResponse;
import org.springframework.stereotype.Service;

@Service
public class CustomModelService {
    private final ChatLanguageModel customModel;

    public CustomModelService() {
      customModel = new CustomChatModel();
    }

    public String generate(String prompt) {
      return customModel.generate(prompt);
    }

    public static class CustomChatModel implements ChatLanguageModel {
      @Override
      public ChatResponse generate(List<ChatMessage> messages) {
            // 实现自定义逻辑
            String response = "自定义模型生成的响应";
            return ChatResponse.builder()
                  .message(AiMessage.from(response))
                  .build();
      }
    }
}
（八）自界说工具

1. 焦点概念

自界说工具允许开发者根据需求实现自己的工具，例如调用外部API或执行特定操作。
2. 应用场景



[*]调用外部API：例如调用天气API获取天气信息。
[*]执行特定操作：例如调用体系下令执行操作。
3. 案例代码

import dev.langchain4j.agent.Agent;
import dev.langchain4j.agent.AgentToolCall;
import dev.langchain4j.agent.AgentToolCallResult;
import dev.langchain4j.agent.ToolCall;
import dev.langchain4j.agent.ToolCallResult;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolRegistry;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;

@Service
public class CustomToolService {
    private final ChatLanguageModel model;
    private final ToolRegistry toolRegistry;

    public CustomToolService() {
      model = new OpenAiChatModel();
      toolRegistry = new ToolRegistry();
    }

    public String execute(String userMessage) {
      Agent agent = Agent.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .build();

      return agent.execute(userMessage);
    }

    @Tool(name = "customTool", description = "自定义工具")
    public String customTool(String input) {
      // 实现自定义逻辑
      return "自定义工具的响应：" + input;
    }
}
（九）自界说链

1. 焦点概念

自界说链允许开发者根据需求实现自己的链，例如将多个任务串联起来。
2. 应用场景



[*]串联多个任务：例如先辈行文本生成，再进行情感分析。
[*]实现复杂逻辑：例如根据条件选择差别的任务。
3. 案例代码

import dev.langchain4j.chain.Chain;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;

@Service
public class CustomChainService {
    private final ChatLanguageModel model;

    public CustomChainService() {
      model = new OpenAiChatModel();
    }

    public String execute(String userMessage) {
      CustomChain chain = new CustomChain(model);
      return chain.execute(userMessage);
    }

    public static class CustomChain implements Chain {
      private final ChatLanguageModel model;

      public CustomChain(ChatLanguageModel model) {
            this.model = model;
      }

      @Override
      public String execute(String input) {
            // 实现自定义逻辑
            String response = model.generate(input);
            // 进行后续处理
            return response;
      }
    }
}
四、实战案例

（一）案例背景

假设我们正在开发一个智能客服体系，需要实现以下功能：

[*]用户可以与客服机器人进行对话。
[*]客服机器人可以或许根据用户的问题提供准确的答案。
[*]客服机器人可以或许调用外部API获取实时信息，例如天气信息。
（二）项目结构

src/main/java/com/example/aiassist
├── controller
│   ├── AiController.java
├── service
│   ├── ChatService.java
│   ├── FunctionCallingService.java
│   ├── RagService.java
│   ├── ToolCallingService.java
├── model
│   ├── CustomChatModel.java
│   ├── CustomTool.java
├── config
│   ├── AppConfig.java
（三）代码实现

1. 控制器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/ai")
public class AiController {
    private final ChatService chatService;
    private final FunctionCallingService functionCallingService;
    private final RagService ragService;
    private final ToolCallingService toolCallingService;

    @Autowired
    public AiController(ChatService chatService, FunctionCallingService functionCallingService, RagService ragService, ToolCallingService toolCallingService) {
      this.chatService = chatService;
      this.functionCallingService = functionCallingService;
      this.ragService = ragService;
      this.toolCallingService = toolCallingService;
    }

    @PostMapping("/chat")
    public String chat(@RequestBody String userMessage) {
      return chatService.chat(userMessage);
    }

    @PostMapping("/function-calling")
    public String functionCalling(@RequestBody String userMessage) {
      return functionCallingService.execute(userMessage);
    }

    @PostMapping("/rag")
    public String rag(@RequestBody String userMessage) {
      return ragService.rag(userMessage);
    }

    @PostMapping("/tool-calling")
    public String toolCalling(@RequestBody String userMessage) {
      return toolCallingService.execute(userMessage);
    }
}
2. 服务层

import dev.langchain4j.agent.Agent;
import dev.langchain4j.agent.AgentToolCall;
import dev.langchain4j.agent.AgentToolCallResult;
import dev.langchain4j.agent.ToolCall;
import dev.langchain4j.agent.ToolCallResult;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolRegistry;
import dev.langchain4j.chain.ConversationalRetrievalChain;
import dev.langchain4j.chain.RetrievalAugmentedGenerationChain;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentLoader;
import dev.langchain4j.data.document.FileDocumentLoader;
import dev.langchain4j.data.segment.TextSegmenter;
import dev.langchain4j.data.segment.TextSegmenterFactory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.retrieval.Retriever;
import dev.langchain4j.retrieval.vectorstore.VectorStoreRetriever;
import dev.langchain4j.vectorstore.VectorStore;
import dev.langchain4j.vectorstore.VectorStoreFactory;
import org.springframework.stereotype.Service;

@Service
public class ChatService {
    private final ChatLanguageModel model;
    private final ToolRegistry toolRegistry;
    private final Retriever retriever;

    public ChatService() {
      model = new OpenAiChatModel();
      toolRegistry = new ToolRegistry();
      VectorStore vectorStore = VectorStoreFactory.create();
      retriever = new VectorStoreRetriever(vectorStore);
    }

    public String chat(String userMessage) {
      ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .retriever(retriever)
                .build();
      return chain.execute(userMessage);
    }

    public String functionCalling(String userMessage) {
      Agent agent = Agent.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .build();
      return agent.execute(userMessage);
    }

    public String rag(String userMessage) {
      RetrievalAugmentedGenerationChain chain = RetrievalAugmentedGenerationChain.builder()
                .chatLanguageModel(model)
                .retriever(retriever)
                .build();
      return chain.execute(userMessage);
    }

    public String toolCalling(String userMessage) {
      Agent agent = Agent.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .build();
      return agent.execute(userMessage);
    }

    @Tool(name = "search", description = "搜索信息")
    public String search(String query) {
      // 实现搜索逻辑
      return "搜索结果：" + query;
    }

    @Tool(name = "weather", description = "获取天气信息")
    public String getWeather(String location) {
      // 实现获取天气信息的逻辑
      return "天气信息：" + location;
    }

    public void loadDocuments() {
      DocumentLoader documentLoader = new FileDocumentLoader("path/to/documents");
      List<Document> documents = documentLoader.load();
      TextSegmenter segmenter = TextSegmenterFactory.create();
      List<TextSegment> segments = segmenter.segment(documents);
      retriever.add(segments);
    }
}
3. 自界说模子

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.ChatMessage;
import dev.langchain4j.model.chat.ChatResponse;
import org.springframework.stereotype.Service;

@Service
public class CustomChatModelService {
    private final ChatLanguageModel customModel;

    public CustomChatModelService() {
      customModel = new CustomChatModel();
    }

    public String generate(String prompt) {
      return customModel.generate(prompt);
    }

    public static class CustomChatModel implements ChatLanguageModel {
      @Override
      public ChatResponse generate(List<ChatMessage> messages) {
            // 实现自定义逻辑
            String response = "自定义模型生成的响应";
            return ChatResponse.builder()
                  .message(AiMessage.from(response))
                  .build();
      }
    }
}
4. 自界说工具

import dev.langchain4j.agent.Agent;
import dev.langchain4j.agent.AgentToolCall;
import dev.langchain4j.agent.AgentToolCallResult;
import dev.langchain4j.agent.ToolCall;
import dev.langchain4j.agent.ToolCallResult;
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.agent.tool.ToolRegistry;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.stereotype.Service;

@Service
public class CustomToolService {
    private final ChatLanguageModel model;
    private final ToolRegistry toolRegistry;

    public CustomToolService() {
      model = new OpenAiChatModel();
      toolRegistry = new ToolRegistry();
    }

    public String execute(String userMessage) {
      Agent agent = Agent.builder()
                .chatLanguageModel(model)
                .toolRegistry(toolRegistry)
                .build();

      return agent.execute(userMessage);
    }

    @Tool(name = "customTool", description = "自定义工具")
    public String customTool(String input) {
      // 实现自定义逻辑
      return "自定义工具的响应：" + input;
    }
}
五、总结

通过本文的详细介绍，我们已经完成了在SpringBoot中整合LangChain4j的全过程。从基础的对话本领、会话记忆，到高级的Function Calling、RAG、工具调用和自界说功能，LangChain4j为Java开发者提供了一个强大且灵活的框架来构建基于AI大模子的应用程序。通过实战案例，我们展示了如何将这些功能应用到实际项目中，资助读者更好地理解和掌握。
在实际开发中，开发者可以根据详细需求灵活选择和组合LangChain4j提供的功能，充实发挥AI大模子的本领，为用户提供更加智能和高效的解决方案。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

查看完整版本: 【微服务】SpringBoot整合LangChain4j 操作AI大模子实战详解