package com.qjc.demo;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

public HelloAI {

public static void main(String[] args) {

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

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

System.out.println(answer);

}

}

运行代码结果为：

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

这样，我们使用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";

}

//其他代码

}

在底层在构造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();

多轮对话

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

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

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

model.generate("请重复")

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

package com.qjc.demo;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

public class HelloAI {

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("请重复"));

}

}

运行结果如下：

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

----

请重复

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

package com.qjc.demo;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

public class HelloAI {

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("我叫什么"));

}

}

运行结果为：

你好小齐，有什么可以帮助你的吗？

----

抱歉，我不知道您的名字。您可以告诉我您的名字吗？我可以记住它并以后称呼您。

一样的情况，因为第二次调用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);

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

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

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

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

package com.qjc.demo;

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;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

public class HelloAI {

public static void main(String[] args) {

ChatLanguageModel model = OpenAiChatModel.builder()

.baseUrl("http://langchain4j.dev/demo/openai/v1")

.apiKey("demo")

.build();

UserMessage userMessage1 = UserMessage.userMessage("你好，我是小齐");

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());

}

}

代码执行结果为：

你好，小齐。有什么可以帮助你的吗？

----

您的名字是周瑜。有什么其他问题我可以帮忙解答吗？

其中重点代码为：

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

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

打字机流式响应

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

package com.qjc.demo;

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;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

public class HelloAI {

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

}

});

}

}

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

整合SpringBoot

先引入SpringBoot：

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>3.2.1</version>

</parent>

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

然后定义SpringBoot启动类：

package com.qjc.demo;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

@SpringBootApplication

public class Main {

public static void main(String[] args) {

SpringApplication.run(Main.class, args);

}

}

然后定义HelloAIController：

package com.qjc.demo.controller;

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;

/***

* @projectName langchain4j-project-1

* @packageName com.qjc.demo.controller

* @author qjc

* @description TODO

* @Email qjc1024@aliyun.com

* @date 2024-10-12 10:00

**/

@RestController

public class HelloAIController {

@Autowired

private ChatLanguageModel chatLanguageModel;

@GetMapping("/hello")

public String hello(){

return chatLanguageModel.generate("你好啊");

}

}

配置api-key：

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

启动SpringBoot并访问：

ModerationModel