【微服务】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的应用程序，如聊天机器人、问答系统、文本生成等。

（二）主要特点

1. 模块化架构：允许开发者根据需要选择和使用特定功能，如模型集成、数据加载、链式调用等。
2. 支持多种LLM提供商：如OpenAI、Hugging Face等，方便切换和集成不同模型。
3. 提供链式调用功能：允许将多个任务串联，如文本生成后自动进行情感分析。
4. 内置多种数据加载器和处理器：支持从不同来源加载数据并进行预处理。
5. 提供丰富的API和扩展点：开发者可以自定义组件以满足特定需求。

（三）核心组件

LangChain4j的核心组件包括语言模型（Language Model）、记忆（Memory）、工具（Tool）等。其中，语言模型是核心，负责生成文本；记忆用于存储对话历史，以便模型能够进行上下文相关的回答；工具则可以扩展模型的能力，例如进行搜索、调用API等。

（四）核心优势

1. 简单易用：提供了简洁的API，方便开发者快速上手。
2. 灵活性高：支持多种语言模型和工具，可以根据需求灵活组合。
3. 安全性强：提供了API Key管理等功能，保障数据安全。

（五）核心应用场景

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

• 聊天机器人：通过对话能力实现智能客服、虚拟助手等。
• 问答系统：结合知识库，提供准确的问答服务。
• 文本生成：生成文章、故事、代码等。

三、SpringBoot整合LangChain4j

（一）前置准备

1. 获取API Key

   • 如果使用OpenAI的模型，需要在OpenAI官网注册账号并获取API Key。
   • 将API Key存储在环境变量或配置文件中，避免直接写在代码里。

2. 导入基础依赖

   • 在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>

3. 添加配置文件

   • 在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;
        }
    }
}

四、实战案例

（一）案例背景

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

1. 用户可以与客服机器人进行对话。
2. 客服机器人能够根据用户的问题提供准确的答案。
3. 客服机器人能够调用外部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大模型的能力，为用户提供更加智能和高效的解决方案。