学静思语

Menu

学静思语
Published on 2025-06-22 / 30 Visits
0
0

LangChain4j学习笔记

#LangChain4j

LangChain4j学习笔记

一、LangChain4j

1. 官方网址

2. 参考文档

image-20250620101203031

二、快速开始

1. 创建父项目

  • 配置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.leon.rabbitmq_study</groupId>
    <artifactId>langchain4j</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>langchain4j_quick_start</module>
    </modules>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--spring boot的版本-->
        <springboot.version>3.3.8</springboot.version>
    </properties>

    <!--统一管理依赖版本-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${springboot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>dev.langchain4j</groupId>
                <artifactId>langchain4j-bom</artifactId>
                <version>1.1.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${springboot.version}</version>
            </plugin>
        </plugins>
    </build>


</project>

2. 创建子项目

  • 配置pom文件

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain4j_quick_start</artifactId>

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

    <dependencies>
        <!--导入spring boot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置application文件

    server:
  port: 8080
spring:
  application:
    name: langchain4j-application
langchain4j:
  open-ai:
    chat-model:
      # 配置API-KEY
      api-key: api-key
      # 配置模型名称
      model-name: qwen-turbo
      # 配置base-url
      base-url: https://dashscope.aliyuncs.com/compatible-mode/v1

  • 创建启动类

    package com.langchain4j.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @date 2025/6/20
 * @author: l
 */
@SpringBootApplication
public class LangChain4jStartApplication {

    public static void main(String[] args) {

        SpringApplication.run(LangChain4jStartApplication.class, args);

    }

}

  • 创建controller

    package com.langchain4j.study.controller;

import dev.langchain4j.model.chat.ChatModel;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @date 2025/6/20
 * @author: l
 */
@RestController
@RequestMapping("/hello")
public class QuickStartController {

    @Resource
    private ChatModel chatModel;

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg") String message){

        return chatModel.chat(message);

    }
}

三、模型相关相关API

1. API介绍

  • 官方参考网址：https://docs.langchain4j.dev/tutorials/chat-and-language-models

    • LanguageModel：过时了

    • ChatModel：聊天模型

    • UserMessage：用户输入的信息

    • AiMessage：大模型生成的信息

    • SystemMessage：系统消息，可以在大模型在对话时预设角色、设置其行为方式、应答分格等

    • EmbeddingModel：文本转换成向量模型

    • ImageModel：生成和编辑图片模型

    • ModerationModel：检查文本是否包含有害内容

    • ScoringModel：对多段文本进行评分、排序，对RAG非常有用

2. ChatAPI的使用

  • 创建项目，配置依赖

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchaint4j_chatapi</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置文件application

    • 官方推荐将api-key保存的环境变量中，以防暴露
    server:
  port: 8080
spring:
  application:
    name: langchain4j-chatapi-application

  • 在配置类中，配置apiKey，modelName，beseUrl

     /**
     * 这里使用接口来接收，因为OPenAiChatModel是ChatModel的实现
      * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {
        return OpenAiChatModel.builder() // 获取OpenAiChatModelBuilder对象
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // api-key，从环境变量中获取
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 基本路径
                .modelName("qwen-turbo") // 设置模型名称
                .build(); // 创建对象
    }

  • 创建controller

        @Resource
    private ChatModel chatModel;
    /**
     * 使用最简单的方式进行对话
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg",defaultValue = "请问你是哪谁") String message){
        // 进行对话
        return chatModel.chat(message);

    }

    /**
     * 使用重载方法
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat2")
    public String chat2(@RequestParam(value = "msg") String message){
        // 进行对话
        // UserMessage.from的作用是去除空格和判断是否为空，如果为空则包异常
        ChatResponse chat = chatModel.chat(UserMessage.from(message));
        // 返回结果
        return  chat.aiMessage().text();
    }

3. 高级AI服务API

3.1 简单配置

  • 创建一个Service类

    public interface ChatAssistant {
   // 简单版本
   String chat(String message);
}

  • 在配置类中绑定

      /**
     * 高级Ai服务API：
     *  ①其理念是将与 LLM 和其他组件交互的复杂性隐藏在简单的 API 背后
     *  ②也可以理解为解耦，将LangChain4j的接口调用隐藏起来，将自定义的接口暴露，也就是只对定义暴露的接口进行操作，屏蔽对LangChain4j接口的操作从而达到解耦
     *  ③其底层的实现原理为动态代理
     * @param chatModel 会话接口
     * @return ChatAssistant
     */
    @Bean
    public ChatAssistant chatAssistant(ChatModel chatModel) {
        // 实现绑定
        return AiServices.create(ChatAssistant.class,chatModel);

        // 方式二
        //return AiServices.builder(ChatAssistant.class)
        //        .chatModel(chatModel)
        //        .build();
    }

  • 创建Controller

       @Resource
    private ChatAssistant chatAssistant;
	/**
     * 使用你高级AI服务实现解耦
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat3")
    public String chat3(@RequestParam(value = "msg") String message){

        return chatAssistant.chat(message);

    }

3.2 高级配置

  • 可以配置系统小消息

     /**
       * 设置系统消息
       * @param message 用户输入的信息
       * @return String
       */
      @SystemMessage("你是张三，一个高级的Java工程师")
      String systemChat(String message);

  • 可以配置用户消息

    /**
       * 设置用户消息
       *  ①标注UserMessage注解不管用户如何输入，与大模型对话的语句一直都是UserMessage注解中的内容
       *  ②如果想要用户请求过来的message生效可以与@V注解和{{}}实现
       * @param message 用户输入的信息
       * @return String
       */
      //@UserMessage("MySQL是什么？")
      @UserMessage("你是一个精通Java的工程，需要你回答：{{msg}}")
      String chat(@V("msg") String message);

  • 可以通过注解方式实现绑定模型

    package com.langchain4j.chatapi.service;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.V;
import dev.langchain4j.service.spring.AiService;

/**
 * @date 2025/6/20
 * @author: l
 */
// 如果不想去配置类中进行模型绑定可以使用@AiService注解
@AiService
public interface ChatAssistant {

      //String chat(String message);

      /**
       * 设置系统消息
       * @param message 用户输入的信息
       * @return String
       */
      @SystemMessage("你是张三，一个高级的Java工程师")
      String systemChat(String message);

      /**
       * 设置用户消息
       *  ①标注UserMessage注解不管用户如何输入，与大模型对话的语句一直都是UserMessage注解中的内容
       *  ②如果想要用户请求过来的message生效可以与@V注解和{{}}实现
       * @param message 用户输入的信息
       * @return String
       */
      //@UserMessage("MySQL是什么？")
      @UserMessage("你是一个精通Java的工程，需要你回答：{{msg}}")
      String chat(@V("msg") String message);
}

  • 说明

    • @UserMessage和@SystemMessage都有一个共同的属性：fromResource用来读取资源中的提示模板。

  • 学习参考

四、LangChain4j常用配置

1. 常用配置

  • 日志配置
  • 监控
  • 重试机制
  • 超时机制

2. 日志配置

  • 创建项目，配置pom文件

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain_config</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置application文件

    • 添加配置
    # 这里配置了，在配置类中则无需配置了
#langchain4j.open-ai.chat-model.log-requests=true
#langchain4j.open-ai.chat-model.log-responses=true
logging.level.dev.langchain4j=debug

  • 配置类中添加配置

    • 在ChatModel设置时添加
    /**
     * 配置ChatModel接口
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder() // 获取OpenAiChatModerBuilder对象
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-key
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-turbo") // 设置模型名称
/** 此处添加 ---->*/ .logRequests(true) // 开启请求时日志
/** 此处添加 ---->*/ .logResponses(true) // 开启响应时日志
                .build(); // 创建OpenAiChatModel

    }

  • 学习参考

3. 监控

  • 创建一个监听类

    package com.langchain4j.config.listener;

import dev.langchain4j.model.chat.listener.ChatModelErrorContext;
import dev.langchain4j.model.chat.listener.ChatModelListener;
import dev.langchain4j.model.chat.listener.ChatModelRequestContext;
import dev.langchain4j.model.chat.listener.ChatModelResponseContext;
import lombok.extern.slf4j.Slf4j;

import java.util.UUID;

/**
 * @date 2025/6/20
 * @author: l
 */

@Slf4j
public class MyChatModelListener implements ChatModelListener {

    /**
     *  监听请求前
     * @param requestContext
     */
    @Override
    public void onRequest(ChatModelRequestContext requestContext) {

        // 生成UUID
        String uuid = UUID.randomUUID().toString();

        requestContext.attributes().put("uuid", uuid);

        log.info("========================>请求的内容 requestContext：{}，UUID：{}",requestContext ,uuid );
    }

    /**
     * 监听请求后
     * @param responseContext
     */
    @Override
    public void onResponse(ChatModelResponseContext responseContext) {

        log.info("========================>响应的内容 responseContext：{}，UUID：{}",responseContext,responseContext.attributes().get("uuid") );

    }

    /**
     * 监听发生异常后
     * @param errorContext
     */
    @Override
    public void onError(ChatModelErrorContext errorContext) {

        log.info("========================>异常内容为 errorContext：{}",errorContext.error().getMessage());

    }
}

  • 在配置类中，加入到模型中

    return OpenAiChatModel.builder() // 获取OpenAiChatModerBuilder对象
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-key
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-turbo") // 设置模型名称
                .logRequests(true) // 开启请求时日志
                .logResponses(true) // 开启响应时日志
/** 此处添加-->*/                .listeners(List.of(new MyChatModelListener())) // 加入监听，可以通过匿名内部类的方式实现ChatModelListener
                .build(); // 创建OpenAiChatModel

  • 学习参考

4. 重试机制

  • 通过配置类进行配置

     /**
     * 配置ChatModel接口
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder() // 获取OpenAiChatModerBuilder对象
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-key
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-turbo") // 设置模型名称
                .logRequests(true) // 开启请求时日志
                .logResponses(true) // 开启响应时日志
 /**此处添加-->*/.maxRetries(1) // 重试机制
                .listeners(List.of(new MyChatModelListener())) // 加入监听，可以通过匿名内部类的方式实现ChatModelListener
                .build(); // 创建OpenAiChatModel

    }

  • 配置文件的方式为

    # 这个配置存在一些问题，设置重试次数失败
langchain4j.open-ai.chat-model.max-retries=重试次数

  • 学习参考

5. 超时机制

  • 通过配置类进行配置

     /**
     * 配置ChatModel接口
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder() // 获取OpenAiChatModerBuilder对象
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-key
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-turbo") // 设置模型名称
                .logRequests(true) // 开启请求时日志
                .logResponses(true) // 开启响应时日志
                .maxRetries(1) // 重试机制
 /**此处添加-->*/.timeout(Duration.ofSeconds(6)) // 设置超时间单位为秒
                .listeners(List.of(new MyChatModelListener())) // 加入监听，可以通过匿名内部类的方式实现ChatModelListener
                .build(); // 创建OpenAiChatModel

    }

  • 通过application文件进行配置

    # 单位为秒
langchain4j.open-ai.chat-model.timeout=6

五、LangChain4j多模态

1. 创建项目，配置文件

  • 配置pom文件

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain4j_multimodality</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置配置文件‘

    server:
  port: 8080
spring:
  application:
    name: langchain4j-multimodality-application

  • 配置配置类

    package com.langchain4j.multimodality.config;

import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @date 2025/6/21
 * @author: l
 */
@Configuration
public class LangChain4jConfig {

    /**
     * 配置模型参数，如：API-KEY、BAS-URL、MODEL-NAME
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel(){


        return OpenAiChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY"))
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1")
                .modelName("qwen-vl-max-2025-04-08")
                .build();

    }

}

  • 创建controller

    package com.langchain4j.multimodality.controller;

import dev.langchain4j.data.message.ImageContent;
import dev.langchain4j.data.message.TextContent;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.chat.response.ChatResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.util.Base64;

/**
 * @date 2025/6/21
 * @author: l
 */
@RestController
@RequestMapping("/multimodality")
public class MultimodalityController{

    @Autowired
    private ChatModel chatModel;

    @Value("classpath:static/img/test.png")
    private Resource resource;

    /**
     *
     * @param prompt 用户提示词
     * @return String
     * @throws IOException getContentAsByteArray
     */
    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg") String prompt) throws IOException {
        // 获取图片的二进制数据
        byte[] content = resource.getContentAsByteArray();
        // 将二进制数据转换成Base64字符串
        String encode = Base64.getEncoder().encodeToString(content);
        // 将数据封装进ImageContent
        ImageContent imageContent = ImageContent.from(encode, "img/png");
        // 将数据保存UserMessage
        UserMessage userMessage = UserMessage.from(
                TextContent.from("从以下图片中获取来源网站的名称和9.30的上证指数"),
                imageContent
        );
        // 进行对话，获取结果
        ChatResponse chatResponse = chatModel.chat(userMessage);

        return chatResponse.aiMessage().text();

    }


}

  • 创建启动类

    package com.langchain4j.multimodality;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @date 2025/6/21
 * @author: l
 */
@SpringBootApplication
public class LangCain4jMultimodalityApplication {


    public static void main(String[] args) {

        SpringApplication.run(LangCain4jMultimodalityApplication.class, args);

    }

}

  • 学习参考

六、流式输出

1. 创建项目，然后进行配置

  • 配置依赖

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain4j_stream</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <!--导入流式输出依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

  • 配置配置文件

    server:
  port: 8080
spring:
  application:
    name: langchain4j-stream-application

  • 创建AssistantServie类

    package com.langchain4j.stream.service;

import dev.langchain4j.service.TokenStream;
import dev.langchain4j.service.spring.AiService;
import reactor.core.publisher.Flux;

/**
 * @date 2025/6/21
 * @author: l
 */
//@AiService
public interface StreamChatAssistant {

    /**
     *  这个方法如果想要使用的话，需要与ChatModel进行绑定
     * @param prompt 用户输入的信息
     * @return String 
     */
    String chat(String prompt);

    /**
     * 这个方法如果需要使用则需要与StreamingChatModel绑定
     * 流式输出
     * @param prompt  用户输入的信息
     * @return Flux<String>
     */
    Flux<String> streamChat(String prompt);

    /**
     * 这个方法如果需要使用则需要与StreamingChatModel绑定
     * @param prompt 用户输入的信息
     * @return  TokenStream
     */
    TokenStream tokenStream(String prompt);
}

  • 配置配置类

    package com.langchain4j.stream.config;

import com.langchain4j.stream.service.StreamChatAssistant;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.chat.StreamingChatModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;
import dev.langchain4j.service.AiServices;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @date 2025/6/21
 * @author: l
 */
@Configuration
public class LangChian4jConfig {

    /**
     * 配置StreamingChatModel接口
     * @return  StreamingChatModel
     */
    @Bean
    public StreamingChatModel streamingChatModel() {

        return OpenAiStreamingChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-KEY
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-vl-max-2025-04-08") // 设置模型名称
                .logRequests(true) // 配置请求前日志输出
                .logResponses(true) // 配置响应后日志输出
                .build(); // 创建OpenAiChatModel对象

    }

    /**
     * 配置ChatModel接口
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-KEY
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-vl-max-latest") // 设置模型名称
                .logRequests(true) // 配置请求前日志输出
                .logResponses(true) // 配置响应后日志输出
                .build(); // 创建OpenAiChatModel对象

    }


    /**
     * 使用高级AI服务实现接口绑定
     * @param streamingChatModel StreamingChatModel
     * @return StreamChatAssistant
     */
    @Bean
    public StreamChatAssistant streamChatAssistant(StreamingChatModel streamingChatModel, ChatModel chatModel) {


        //return AiServices.create(StreamChatAssistant.class,streamingChatModel);

        return AiServices.builder(StreamChatAssistant.class) // 需要绑定的接口
                .chatModel(chatModel)
                .streamingChatModel(streamingChatModel) // 与什么模型进行绑定
                .build(); // 创建

    }

}

  • 创建Controller

    package com.langchain4j.stream.controller;

import com.langchain4j.stream.service.StreamChatAssistant;
import dev.langchain4j.model.chat.StreamingChatModel;
import dev.langchain4j.model.chat.response.ChatResponse;
import dev.langchain4j.model.chat.response.StreamingChatResponseHandler;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.service.TokenStream;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Scheduler;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;

/**
 * @date 2025/6/21
 * @author: l
 */
@RestController
@RequestMapping("/stream")
public class StreamController {

    @Resource
    private StreamingChatModel streamingChatModel;

    @Resource
    private StreamChatAssistant streamChatAssistant;


    /**
     * 使用ChatModel进行对话
     * @param prompt 用户输入的信息
     * @return  String
     */
    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg") String prompt){

       return streamChatAssistant.chat(prompt);

    }

    /**
     * 使用高级AI服务实现流式输出
     * @param prompt 用户输入的信息
     * {@code  Flux<String> streamChat(String prompt);}
     * @return Flux<String>
     */
    @GetMapping(value = "/chat2",produces = "text/html;charset=utf-8")
    public Flux<String> chat2(@RequestParam(value = "msg") String prompt){

        return streamChatAssistant.streamChat(prompt);

    }

    /**
     * 使用StreamingChatModel
     * {@code default void chat(String userMessage, StreamingChatResponseHandler handler)}
     * @param prompt 用户输入的信息
     */
    @GetMapping(value = "/chat3",produces = "text/html;charset=utf-8")
    public void chat3(@RequestParam(value = "msg") String prompt){


        // 调用大模型
        streamingChatModel.chat(prompt, new StreamingChatResponseHandler() {
            /**
             *  大模型生成下一个部分内容是时调用
             * @param partialResponse The partial response (usually a single token), which is a part of the complete response.
             */
            @Override
            public void onPartialResponse(String partialResponse) {
                //System.out.println("==========>"+partialResponse);
            }

            /**
             * 大模型完成回答后调用
             * @param completeResponse The complete response generated by the model.
             *                         For textual responses, it contains all tokens from {@link #onPartialResponse} concatenated.
             */
            @Override
            public void onCompleteResponse(ChatResponse completeResponse) {
                System.out.println("==========> ChatResponse"+completeResponse.aiMessage().text());
            }

            /**
             *  发生错误时调用
             * @param error The error that occurred（表示当前发生的异常）
             */
            @Override
            public void onError(Throwable error) {

            }
        });

    }

    /**
     * 使用异步对象存放和获取结果
     * @param prompt 用户输入的信息
     * @return String
     */
    @GetMapping("/chat4")
    public String chat4(@RequestParam(value = "msg") String prompt){


        // 创建一个异步对象，CompletableFuture
        CompletableFuture<ChatResponse> completableFuture = new CompletableFuture<>();

        streamingChatModel.chat(prompt, new StreamingChatResponseHandler() {

            @Override
            public void onPartialResponse(String partialResponse) {

            }

            @Override
            public void onCompleteResponse(ChatResponse completeResponse) {
                   // 将结果设置进入CompletableFuture
                   completableFuture.complete(completeResponse);
            }

            @Override
            public void onError(Throwable error) {

            }
        });

        // 获取结果并返回
        return completableFuture.join().aiMessage().text();

    }

    /**
     * 使用了TokenStream
     * @param prompt 用户输入的信息
     * <pre>
     *     {@code
     *              @Override
     *             public void onPartialResponse(String partialResponse) {
     *
     *             }
     *
     *             @Override
     *             public void onCompleteResponse(ChatResponse completeResponse) {
     *
     *             }
     *
     *             @Override
     *             public void onError(Throwable error) {
     *
     *             }
     *
     *     }
     * </pre>
     */
    @GetMapping("/chat5")
    public void chat5(@RequestParam(value = "msg") String prompt){

        TokenStream tokenStream = streamChatAssistant.tokenStream(prompt);

        // 这里的三个方法和StreamingChatResponseHandler的三个方法功能一致
        tokenStream.onPartialResponse(System.out::print)
                .onCompleteResponse(System.out::println)
                .onError(Throwable::printStackTrace)
                .start(); // 开始对话


    }


}

  • 创建启动类

    package com.langchain4j.stream;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @date 2025/6/21
 * @author: l
 */
@SpringBootApplication
public class LangChain4jStreamApplication {

    public static void main(String[] args) {

        SpringApplication.run(LangChain4jStreamApplication.class, args);

    }

}

  • 学习参考

七、LangChain4j聊天记忆

1. 创建项目，配置文件

  • 配置pom文件

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain4j_memory</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <!--导入流式输出依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置配置文件

    server:
  port: 8080
spring:
  application:
    name: langchain4j-memory-application

  • 创建Assistant接口

    package com.langchain4j.memory.service;

import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.UserMessage;
import reactor.core.publisher.Flux;

/**
 * @date 2025/6/21
 * @author: l
 */
public interface MemoryChatAssistant {
    /**
     * 实现聊天记忆
     * @param memoryId 用户的id
     * @param prompt 用输入的信息
     * @return String
     */
    String chat(@MemoryId Long memoryId, @UserMessage String prompt);

    /**
     * 实现流式输出聊天记忆
     * @param memoryId 用户的id
     * @param prompt 用输入的信息
     * @return Flux<String>
     */
    Flux<String> streamChat(@MemoryId Long memoryId, @UserMessage String prompt);

}

  • 创建配置类

    package com.langchain4j.memory.config;

import com.langchain4j.memory.service.MemoryChatAssistant;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.chat.StreamingChatModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;
import dev.langchain4j.service.AiServices;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @date 2025/6/21
 * @author: l
 */
@Configuration
public class LangChain4jConfig {

    /**
     * 配置ChatModel接口
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-KEY
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-vl-max-latest") // 设置模型名称
                .build(); // 创建OpenAiChatModel对象

    }
    
    /**
     * 配置Stream流式输出模型
     * @return StreamingChatModel
     */
    @Bean
    public StreamingChatModel streamingChatModel() {

        return OpenAiStreamingChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-KEY
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-vl-max-latest") // 设置模型名称
                .build();

    }

    /**
     * 绑定MemoryChatAssistant
     * @param chatModel {@link #chatModel()}
     * @param streamingChatModel {@link #streamingChatModel()}
     * @return MemoryChatAssistant
     */
    @Bean
    public MemoryChatAssistant memoryChatAssistant(ChatModel chatModel,StreamingChatModel streamingChatModel) {

        return AiServices.builder(MemoryChatAssistant.class) // 绑定MemoryChatAssistant接口
                .chatModel(chatModel) // 绑定ChatModel接口
                .streamingChatModel(streamingChatModel)  // 绑定 StreamingChatModel接口
                .chatMemoryProvider(memoryId ->{
                    System.out.println("=================>"+memoryId);
                   return MessageWindowChatMemory.withMaxMessages(100);
                }) // 设置ChatMemory
                .build(); // 创建MemoryChatAssistant对象

    }
}

  • 创建controller

    package com.langchain4j.memory.controller;

import com.langchain4j.memory.service.MemoryChatAssistant;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.model.chat.StreamingChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

/**
 * @date 2025/6/21
 * @author: l
 */
@RestController
@RequestMapping("/memory")
public class MemoryController {

    @Autowired
    private MemoryChatAssistant  memoryChatAssistant;

    @Autowired
    private ChatMemory chatMemory;



    /**
     * 使用高级AI实现聊天记忆
     * @param prompt 用户输入的信息
     * @param id 用户的id
     * @return String
     */
    @GetMapping("/chat")
    public String chat(@RequestParam(value = "msg") String prompt,@RequestParam(value = "id") Long id) {

        return memoryChatAssistant.chat(id,prompt);

    }


    /**
     * 使用流式方式方式实现聊天记忆
     */
    @GetMapping(value = "/chat2",produces = "text/html;charset=utf-8")
    public Flux<String> chat2(@RequestParam(value = "msg") String prompt,@RequestParam(value = "id") Long id){


       return memoryChatAssistant.streamChat(id, prompt);



    }

}

  • 创建启动类

    package com.langchain4j.memory;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @date 2025/6/21
 * @author: l
 */
@SpringBootApplication
public class LangChain4jMemoryApplication {

    public static void main(String[] args) {
        SpringApplication.run(LangChain4jMemoryApplication.class, args);

    }

}

  • 学习参考

八、LangChain提示词

1. 创建项目，配置文件

1.1 使用注解方式

  • 配置项目依赖

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain4j_prompt</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <!--导入流式输出依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

  • 配置配置文件

    server:
  port: 8080
spring:
  application:
    name: langchain4j-memory-application

  • 创建Assistant接口

    /**
     * 注解SystemMessage 表示设置系统消息
     * 注解userMessage 表示设置用户消息
     * @param prompt 用输入的信息
     * @return String
     */
    @SystemMessage("你是一位专业的中国法律顾问，只回答与中国法律相关的问题。" +
            "输出限制：对于其他领域的问题禁止回答，" +
            "直接返回'抱歉，我只能回答中国法律相关的问题。")
    @UserMessage("请回答以下法律问题：{{msg}}")
    String chat(@V("msg") String prompt);

  • 配置配置类

    package com.langchain4j.prompt.config;

import com.langchain4j.prompt.service.PromptAssistant;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @date 2025/6/22
 * @author: l
 */
@Configuration
public class LangChain4jConfig {

    /**
     * 配置ChatModel接口
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-KEY
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-vl-max-latest") // 设置模型名称
                .build(); // 创建OpenAiChatModel对象

    }


    /**
     *  绑定PromptAssistant
     * @return  PromptAssistant
     */
    @Bean
    public PromptAssistant promptAssistant(ChatModel chatModel) {

        return AiServices.create(PromptAssistant.class,chatModel);

    }

}

  • 创建Controller

     @Autowired
    private PromptAssistant promptAssistant;   
	/**
     * 使用高级AI实现提示词
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat")
    public String chat(@RequestParam("msg") String message) {

       return promptAssistant.chat(message);

    }

  • 创建启动类

    package com.langchain4j.prompt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @date 2025/6/22
 * @author: l
 */
@SpringBootApplication
public class LangChain4jPromptApplication {

    public static void main(String[] args) {

        SpringApplication.run(LangChain4jPromptApplication.class, args);

    }

}

1.2 使用对象作为参数

  • 创建entity类

    package com.langchain4j.prompt.entity;

import dev.langchain4j.model.input.structured.StructuredPrompt;

/**
 * @date 2025/6/22
 * @author: l
 */

@StructuredPrompt("根据中国{{legal}}法律，解答以下问题：{{prompt}}")
public record PromptEntity(String legal,String prompt) {
}

  • 创建Assistant接口的API

     /**
     * 注解SystemMessage 表示设置系统消息
     * @param prompt 用输入的信息，此时是一个对象
     * @return String
     */
    @SystemMessage("你是一位专业的中国法律顾问，只回答与中国法律相关的问题。" +
            "输出限制：对于其他领域的问题禁止回答，" +
            "直接返回'抱歉，我只能回答中国法律相关的问题。")
    String chat(PromptEntity prompt);

  • 创建Controller的API

    /**
     * 使用高级AI实现提示词，通过对象作为参数
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat2")
    public String chat2(@RequestParam("msg") String message) {

        return promptAssistant.chat(new PromptEntity("土地法", message));

    }

1.3 使用PromptTemplate方式

  • 创建Controller的API

    /**
 * 使用PromptTemplate设置提示词
 * @param message 用户输入的信息
 * @return String
 */
@GetMapping("/chat3")
public String chat3(@RequestParam("msg") String message) {

    // 设置提示词模板，如果不是使用Map集合进行填充，则需要使用it作为占位
    //PromptTemplate template =
    //        PromptTemplate.from("你是一位专业的中国法律顾问，只回答与中国法律相关的问题。" +
    //                "输出限制：对于其他领域的问题禁止回答，直接返回'抱歉，我只能回答中国法律相关的问题。"+
    //                "请回答以下法律问题：{{it}}");
    //
    // 填充数据
    //Prompt apply = template.apply(message);

    // 设置提示词模板
    PromptTemplate template =
            PromptTemplate.from("你是一位专业的中国法律顾问，只回答与中国法律相关的问题。" +
                    "输出限制：对于其他领域的问题禁止回答，直接返回'抱歉，我只能回答中国法律相关的问题。"+
                    "请回答以下法律问题：{{message}}");
    // 填充数据
    Prompt apply = template.apply(Map.of("message", message));

    return chatModel.chat(apply.text());

}

  • 学习参考

九、LangChain4j函数调用

1. 创建项目，配置文件

  • 配置pom文件

    <?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>
    <parent>
        <groupId>com.leon.rabbitmq_study</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>langchain4j_function</artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--langchain4j框架基本依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>

        <!--高级AI服务API依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

        <!--导入流式输出依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置配置文件

    server:
  port: 8080
spring:
  application:
    name: langchain4j-memory-application

  • 创建配置类

       /**
     * 配置ChatModel模型
     *
     * @return ChatModel
     */
    @Bean
    public ChatModel chatModel() {

        return OpenAiChatModel.builder()
                .apiKey(System.getenv("LANGCHAIN4J_API_KEY")) // 获取API-KEY
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1") // 设置模型地址
                .modelName("qwen-vl-max-latest") // 设置模型名称
                .build();

    }

  • 创建启动类

    package com.langchain4j.function;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @date 2025/6/22
 * @author: l
 */
@SpringBootApplication
public class LangChain4jFunctionApplication {

    public static void main(String[] args) {

        SpringApplication.run(LangChain4jFunctionApplication.class, args);

    }

}

2. 函数和工具的调用

2.1 试用版底层API方式

  • 创建Assistant接口

    package com.langchain4j.function.service;

/**
 * @date 2025/6/22
 * @author: l
 */
public interface FunctionAssistant {

    String chat(String prompt);


}

  • 在配置类中进行绑定

     /**
     * 配置工具
     *  使用的是底层API
     * @return FunctionAssistant
     */
    @Bean
    public FunctionAssistant functionAssistant(ChatModel chatModel) {

        // 创建工具规范
        ToolSpecification toolSpecification = ToolSpecification.builder()
                .name("ticket_tool")
                .description("根据用户提供的信息开发票据")
                .parameters(JsonObjectSchema.builder()
                        .addStringProperty("companyName", "公司名称") //添加String类型的属性
                        .addStringProperty("dutyNumber", "税号") //添加String类型的属性
                        .addStringProperty("amount", "金额，保留三位有效小数") //添加String类型的属性
                        .build())
                .build();
        // 工具执行器
        ToolExecutor toolExecutor = (toolExecutionRequest,memoryId) ->{
            System.out.println("====================> id："+toolExecutionRequest.id());
            System.out.println("====================> name："+toolExecutionRequest.name());
            System.out.println("====================> arguments："+toolExecutionRequest.arguments());
            System.out.println("====================> memoryId"+memoryId);

            // 业务操作

            return "开具成功";
        };



        return AiServices.builder(FunctionAssistant.class)
                .chatModel(chatModel) // 绑定模型
                .tools(Map.of(toolSpecification,toolExecutor)) // 添加工具
                .build();

    }

  • 创建Controller

    package com.langchain4j.function.controller;

import com.langchain4j.function.service.FunctionAssistant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;


/**
 * @date 2025/6/22
 * @author: l
 */
@RestController
@RequestMapping("/function")
public class FunctionController {

    @Autowired
    private FunctionAssistant functionAssistant;


    @GetMapping("/chat")
    public String chat(@RequestParam("msg") String message) {

        return functionAssistant.chat(message);

    }

}

2.2 使用注解方式

  • 创建函数类

    package com.langchain4j.function.service;

import dev.langchain4j.agent.tool.P;
import dev.langchain4j.agent.tool.Tool;
import lombok.extern.slf4j.Slf4j;

/**
 * @date 2025/6/22
 * @author: l
 */
@Slf4j
public class FunctionAnnotationTool {

    /**
     * 通过Tool注解标注的方法称为函数，由大模型决定是否调用
     * 注解P则是表示形参为参数，可以不用标注
     * @param companyName 公司名称
     * @param dutyNumber  税号
     * @param amount 金额，保留三位小数
     * @return String
     */
    @Tool("根据用户提供的信息开发票据")
    public String ticketFunction(@P("公司名称") String companyName,
                                 @P("税号") String dutyNumber,
                                 @P("金额，保留三位小数") Double amount) {

        log.info("companyName =====>{}   dutyNumber =====>{}  amount =====>{}", companyName, dutyNumber, amount);

        // 其它业务操作

        return "success";
    }


}

  • 在配置类中进行绑定和添加函数

     /**
     * 通过注解方式定义 函数
     * @param chatModel {@link #chatModel()}
     * @return FunctionAssistant
     */
    @Bean
    public FunctionAssistant functionAssistant(ChatModel chatModel) {


        return AiServices.builder(FunctionAssistant.class)
                .chatModel(chatModel) // 绑定模型
                .tools(new FunctionAnnotationTool()) // 添加工具
                .build();

    }

3. 动态函数的调用

  • 导入依赖

    <!--导入代码执行引擎依赖-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-code-execution-engine-graalvm-polyglot</artifactId>
        </dependency>

  • 创建Assistant接口

    package com.langchain4j.function.service;

/**
 * @date 2025/6/22
 * @author: l
 */
public interface GraalVMAssistant {

   String chat(String prompt);

}

  • 在配置类中进行绑定

    /**
     * 配置代码执行引擎
     * @param chatModel {@link #chatModel()}
     * @return GraalVMAssistant
     */
    @Bean
    public GraalVMAssistant graalVMAssistant(ChatModel chatModel) {


        return AiServices.builder(GraalVMAssistant.class) // 绑定GraaVMAssistant对象
                .chatModel(chatModel) // 绑定ChatModel
                .tools(new GraalVmJavaScriptExecutionTool()) // 绑定工具
                .build();

    }

  • 在Controller中创建API

    	@Autowired
    private GraalVMAssistant graalVMAssistant;

    /**
     * 实现运行其它语言的函数，即动态函数
     * @param message 用户输入的信息
     * @return String
     */
    @GetMapping("/chat3")
    public String chat3(@RequestParam("msg") String message) {

        String function =
                """
                function fibonacci(n){
                    if(n <= 1) return n
                    return fibonacci(n - 1) + fibonacci(n - 2);
                }
                
                fibonacci({{it}})
                """;
        // 设置提示词模板
        PromptTemplate promptTemplate = PromptTemplate.from(function);
        // 填充占位数据
        Prompt apply = promptTemplate.apply(message);
        // 与大模型进行沟通
        String chat = graalVMAssistant.chat(apply.text());

        System.out.println(chat);

        return chat;

    }

  • 学习参考

Spring Ai学习笔记

Comment