LangChain4j之HelloWorld

什么是LangChain4j

它是Java版本的LangChain，随着大模型的不断发展，如何在程序中更好的利用大模型的能力来提高编程效率是一种趋势，LangChain是这么自己介绍自己的：

LangChain gives developers a framework to construct LLM‑powered apps easily.

意思是：LangChain提供了一个开发框架，使得开发者可以很容易的用来构建具有LLM能力的应用程序。

LLM就是Large Language Model，也就是常说的大语言模型，简称大模型。

个人认为：大模型时代，如何将大模型能力和传统应用相结合，使得传统应用更加智能，是人工智能时代的趋势。以前一个应用要获得智能，需要企业自己投入资源训练模型，而现在只需要接入大模型即可，这种便利性将使得大模型会应用得更为广泛，而如何将大模型能力和Java编程语言相结合，这就是LangChain4j所做的。

注意，大模型的能力远远不止聊天的能力，而LangChain4j就在帮助我们更好的利用大模型的能力，从而帮我们打造出更加智能的应用。

初识LangChain4j

接下来，让我们与LangChain4j初识一下，新建一个Maven工程，然后添加以下依赖：

<?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.timi</groupId>
    <artifactId>langchain4j-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
            <version>${langchain4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.tinylog</groupId>
            <artifactId>tinylog-impl</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.tinylog</groupId>
            <artifactId>slf4j-tinylog</artifactId>
            <version>2.6.2</version>
        </dependency>
    </dependencies>

</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

引入了langchain4j的核心依赖、langchain4j集成OpenAi各个模型的依赖、轻量级实现了slf4j接口的tinylog日志依赖。

和OpenAi的第一次对话

package com.timi;

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

public class _01_HelloWorld {

    public static void main(String[] args) {

        ChatLanguageModel model = OpenAiChatModel.withApiKey("demo");

        String answer = model.generate("你好，你是谁？");

        System.out.println(answer);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行代码结果为：

你好，我是一个人工智能助手。我可以回答你的问题和提供帮助。有什么可以帮到你的吗？
1

这样，我们使用LangChain4j第一次成功的和OpenAi的GPT模型进行了对话，正常来说，调用OpenAi的API接口需要在OpenAi的官网去申请ApiKey才能调用成功，而我这里传入的ApiKey为"demo"却也能调通，这是因为：

public OpenAiChatModel(String baseUrl, String apiKey, String organizationId, String modelName, Double temperature, Double topP, List<String> stop, Integer maxTokens, Double presencePenalty, Double frequencyPenalty, Map<String, Integer> logitBias, String responseFormat, Integer seed, String user, Duration timeout, Integer maxRetries, Proxy proxy, Boolean logRequests, Boolean logResponses, Tokenizer tokenizer) {
	
	baseUrl = (String)Utils.getOrDefault(baseUrl, "https://api.openai.com/v1");
	if ("demo".equals(apiKey)) {
		baseUrl = "http://langchain4j.dev/demo/openai/v1";
	}

	//其他代码
}
1
2
3
4
5
6
7
8
9

在底层在构造OpenAiChatModel时，会判断传入的ApiKey是否等于"demo"，如果等于会将OpenAi的原始API地址"https://api.openai.com/v1"改为"http://langchain4j.dev/demo/openai/v1"，这个地址是langchain4j专门为我们准备的一个体验地址，实际上这个地址相当于是"https://api.openai.com/v1"的代理，我们请求代理时，代理会去调用真正的OpenAi接口，只不过代理会将自己的ApiKey传过去，从而拿到结果返回给我们。

所以，真正开发时，需要大家设置自己的apiKey或baseUrl，可以这么设置：

ChatLanguageModel model = OpenAiChatModel.builder()
	.baseUrl("http://langchain4j.dev/demo/openai/v1")
	.apiKey("demo")
	.build();
1
2
3
4

多轮对话

前面的例子中，我们通过ChatLanguageModel的generate()方法向大模型提出问题：

String answer = model.generate("你好，你是谁？");
1

那如果我继续向大模型说：

model.generate("请重复")
1

那么大模型还记得它之前的回答吗？我们先看看效果，代码如下：

package com.timi;

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

public class _01_HelloWorld {

    public static void main(String[] args) {

        ChatLanguageModel model = OpenAiChatModel.builder()
                .baseUrl("http://langchain4j.dev/demo/openai/v1")
                .apiKey("demo")
                .build();

        System.out.println(model.generate("你好，你是谁？"));
        System.out.println("----");
        System.out.println(model.generate("请重复"));

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果如下：

你好，我是一个聊天机器人，可以回答你的问题和进行对话。有什么可以帮助你的吗？
----
请重复
1
2
3

大模型重复了我第二次跟它说的，而不是重复它的第一次回答，这是因为，目前的代码中，每次调用generate()都是一次新的会话，我再举一个例子：

package com.timi;

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

public class _01_HelloWorld {

    public static void main(String[] args) {

        ChatLanguageModel model = OpenAiChatModel.builder()
                .baseUrl("http://langchain4j.dev/demo/openai/v1")
                .apiKey("demo")
                .build();

        System.out.println(model.generate("你好，我是Timi"));
        System.out.println("----");
        System.out.println(model.generate("我叫什么"));

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果为：

你好Timi，有什么可以帮助你的吗？
----
抱歉，我不知道您的名字。您可以告诉我您的名字吗？我可以记住它并以后称呼您。
1
2
3

一样的情况，因为第二次调用generate()方法是一次单独的会话，那么如何做到使得两次或多次generate()在同一个会话中呢？在LangChain4j中有一个ChatMemory组件，它就是专门用来实现会话功能的，但是它需要结合LangChain4j中的AiService来使用，我们后面再介绍，现在我们先使用笨办法来解决多轮对话的问题。

在ChatLanguageModel中有多个generate()重载方法：

default String generate(String userMessage) {
	return generate(UserMessage.from(userMessage)).content().text();
}

default Response<AiMessage> generate(ChatMessage... messages) {
    return generate(asList(messages));
}

Response<AiMessage> generate(List<ChatMessage> messages);
1
2
3
4
5
6
7
8
9

我们前面使用的就是第一个generate()方法，而第二个和第三个generate()方法都是接收一个ChatMessage集合，并且返回一个AiMessage，那么ChatMessage和AiMessage分别都表示什么意思呢？

ChatMessage是一个接口，表示聊天消息，它有以下四种实现：

1. UserMessage：表示用户发送给大模型的消息
2. AiMessage：表示大模型响应给用户的消息
3. SystemMessage：也是用户发送给大模型的消息，和UserMessage不同在于，SystemMessage一般是应用程序帮用户设置的，举个例子，假如有一个作家应用，那么“请你扮演一名作家，请帮我写一篇关于春天的作文”，其中“请你扮演一名作家”就是SystemMessage，“请帮我写一篇关于春天的作文”就是UserMessage
4. ToolExecutionResultMessage：也是用户发送给大模型的，表示工具的执行结果，关于LangChain4j的工具机制，会在后续介绍，目前可以忽略

我们先重点关注UserMessage和AiMessage，它们就相当于请求和响应，所以如果我们想要实现多轮对话，可以这么实现：

package com.timi;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.output.Response;

public class _01_HelloWorld {

    public static void main(String[] args) {

        ChatLanguageModel model = OpenAiChatModel.builder()
                .baseUrl("http://langchain4j.dev/demo/openai/v1")
                .apiKey("demo")
                .build();


        UserMessage userMessage1 = UserMessage.userMessage("你好，我是Timi");
        Response<AiMessage> response1 = model.generate(userMessage1);
        AiMessage aiMessage1 = response1.content(); // 大模型的第一次响应
        System.out.println(aiMessage1.text());
        System.out.println("----");

        // 下面一行代码是重点
        Response<AiMessage> response2 = model.generate(userMessage1, aiMessage1, UserMessage.userMessage("我叫什么"));
        AiMessage aiMessage2 = response2.content(); // 大模型的第二次响应
        System.out.println(aiMessage2.text());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

代码执行结果为：

你好，Timi。有什么可以帮助你的吗？
----
您的名字是Timi。有什么其他问题我可以帮忙解答吗？
1
2
3

其中重点代码为：

Response<AiMessage> response2 = model.generate(userMessage1, aiMessage1, UserMessage.userMessage("我叫什么"));
1

同样是问"我叫什么"，但是这里我把第一次的问题和答案，也就是我和大模型的历史对话传给了大模型，只有这样，大模型才能结合历史对话知道"我叫什么"。事实上，我们在使用ChatGPT时也是一样的原理，因为ChatGPT需要结合历史对话才更能理解你最新一句话的真正意思。

打字机流式响应

在前面的例子中，当我们通过ChatLanguageModel的generate()方法向大模型提问时，ChatLanguageModel一次性给了整段响应结果，而不是一个字一个字打字机式的回答，不过我们可以使用OpenAiStreamingChatModel来实现打字机效果，代码如下：

package com.timi;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.StreamingResponseHandler;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;

import java.util.concurrent.TimeUnit;

public class _01_HelloWorld {

    public static void main(String[] args) {

        StreamingChatLanguageModel model = OpenAiStreamingChatModel.builder()
                .baseUrl("http://langchain4j.dev/demo/openai/v1")
                .apiKey("demo")
                .build();


        model.generate("你好，你是谁？", new StreamingResponseHandler<AiMessage>() {
            @Override
            public void onNext(String token) {

                System.out.println(token);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }

            @Override
            public void onError(Throwable error) {
                System.out.println(error);
            }
        });

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

这样就能实现打字机效果了。

整合SpringBoot

先引入SpringBoot：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>3.2.1</version>
</parent>
1
2
3
4
5

<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>
	<version>0.27.1</version>
</dependency>
1
2
3
4
5
6
7
8
9
10

然后定义SpringBoot启动类：

package com.timi;

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

@SpringBootApplication
public class Main {

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

1
2
3
4
5
6
7
8
9
10
11
12
13

然后定义HelloController：

package com.timi;

import dev.langchain4j.model.chat.ChatLanguageModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private ChatLanguageModel chatLanguageModel;

    @GetMapping("/hello")
    public String hello(){
        return chatLanguageModel.generate("你好啊");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

配置api-key：

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

启动SpringBoot并访问：

ModerationModel

package com.timi;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.moderation.Moderation;
import dev.langchain4j.model.moderation.ModerationModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiModerationModel;
import dev.langchain4j.model.output.Response;

public class _01_HelloWorld {

    public static void main(String[] args) {
        ModerationModel moderationModel = OpenAiModerationModel.withApiKey("demo");
        Response<Moderation> response = moderationModel.moderate("我要谢谢你");
        System.out.println(response.content().flaggedText());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ModerationModel能够校验输入中是否存在敏感内容。

ImageModel

package com.timi;

import dev.langchain4j.data.image.Image;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.image.ImageModel;
import dev.langchain4j.model.moderation.Moderation;
import dev.langchain4j.model.moderation.ModerationModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiImageModel;
import dev.langchain4j.model.openai.OpenAiModerationModel;
import dev.langchain4j.model.output.Response;

public class _01_HelloWorld {

    public static void main(String[] args) {
        ImageModel imageModel = OpenAiImageModel.builder()
                .baseUrl("http://localhost:3000/v1")
                .apiKey("sk-peszVtFXoLnWK45bB15370Df6f344cAa9a088eF50f9c7302")
                .build();
        Response<Image> response = imageModel.generate("一辆车");
        System.out.println(response.content().url());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ImageModel可以根据提示词来生成图片，默认提供的“demo”key不能用来生成图片，需要大家自己购买apiKey，可以先不买，先学习后面内容。

本节总结

本节我们介绍了LangChain4j的基本使用，以及多轮对话、流式响应的实现，其中我们提到了LangChain4j中的工具机制、AiService机制、ChatMemory机制，接下来我们先学习一下AiService机制。