topdog/supersonic
1
0
Fork 0
mirror of https://github.com/tencentmusic/supersonic.git synced 2025-12-14 13:47:09 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

(improvement)(common) Upgraded langchain4j to version 0.31. (#1174)

Browse Source
This commit is contained in:
lexluo09
2024-06-20 17:31:19 +08:00
committed by GitHub
parent 1df1fe5ad6
commit 92db381b6f
37 changed files with 241 additions and 888 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
common/src/main/java/dev/langchain4j/model/ChatModel.java
View File

@@ -1,30 +0,0 @@
package dev.langchain4j.model;
public enum ChatModel {
ZHIPU("glm"),
ALI("qwen");
private final String modelName;
private ChatModel(String modelName) {
this.modelName = modelName;
}
public String toString() {
return this.modelName;
}
public static ChatModel from(String stringValue) {
ChatModel[] var1 = values();
int var2 = var1.length;
for (int var3 = 0; var3 < var2; ++var3) {
ChatModel model = var1[var3];
if (model.modelName.equals(stringValue)) {
return model;
}
}
throw new IllegalArgumentException("Unknown role: '" + stringValue + "'");
}
}

15
common/src/main/java/dev/langchain4j/model/embedding/EmbeddingModelConfig.java Normal file
View File

@@ -0,0 +1,15 @@
package dev.langchain4j.model.embedding;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class EmbeddingModelConfig {
@Bean
@ConditionalOnMissingBean
public EmbeddingModel embeddingModel() {
return new BgeSmallZhEmbeddingModel();
}
}

5
common/src/main/java/dev/langchain4j/model/embedding/S2OnnxEmbeddingModel.java
View File

@@ -1,12 +1,13 @@
package dev.langchain4j.model.embedding;
import org.apache.commons.lang3.StringUtils;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.apache.commons.lang3.StringUtils;
/**
* An embedding model that runs within your Java application's process.
@@ -51,7 +52,7 @@ public class S2OnnxEmbeddingModel extends AbstractInProcessEmbeddingModel {
try {
return new OnnxBertBiEncoder(
Files.newInputStream(pathToModel),
vocabularyFile,
vocabularyFile.openStream(),
PoolingMode.MEAN
);
} catch (IOException e) {

227
common/src/main/java/dev/langchain4j/model/openai/FullOpenAiChatModel.java
View File

@@ -1,227 +0,0 @@
package dev.langchain4j.model.openai;
import dev.ai4j.openai4j.OpenAiClient;
import dev.ai4j.openai4j.chat.ChatCompletionChoice;
import dev.ai4j.openai4j.chat.ChatCompletionRequest;
import dev.ai4j.openai4j.chat.ChatCompletionResponse;
import dev.ai4j.openai4j.chat.ChatCompletionRequest.Builder;
import dev.langchain4j.agent.tool.ToolSpecification;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.internal.RetryUtils;
import dev.langchain4j.internal.Utils;
import dev.langchain4j.model.ChatModel;
import dev.langchain4j.model.Tokenizer;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.TokenCountEstimator;
import dev.langchain4j.model.output.Response;
import java.net.Proxy;
import java.time.Duration;
import java.util.Collections;
import java.util.List;
public class FullOpenAiChatModel implements ChatLanguageModel, TokenCountEstimator {
private final OpenAiClient client;
private final String modelName;
private final Double temperature;
private final Double topP;
private final List<String> stop;
private final Integer maxTokens;
private final Double presencePenalty;
private final Double frequencyPenalty;
private final Integer maxRetries;
private final Tokenizer tokenizer;
public FullOpenAiChatModel(String baseUrl, String apiKey, String modelName, Double temperature,
Double topP, List<String> stop, Integer maxTokens, Double presencePenalty,
Double frequencyPenalty, Duration timeout, Integer maxRetries, Proxy proxy,
Boolean logRequests, Boolean logResponses, Tokenizer tokenizer) {
baseUrl = Utils.getOrDefault(baseUrl, "https://api.openai.com/v1");
if ("demo".equals(apiKey)) {
baseUrl = "http://langchain4j.dev/demo/openai/v1";
}
timeout = Utils.getOrDefault(timeout, Duration.ofSeconds(60L));
this.client = OpenAiClient.builder().openAiApiKey(apiKey)
.baseUrl(baseUrl).callTimeout(timeout).connectTimeout(timeout)
.readTimeout(timeout).writeTimeout(timeout).proxy(proxy)
.logRequests(logRequests).logResponses(logResponses).build();
this.modelName = Utils.getOrDefault(modelName, "gpt-3.5-turbo");
this.temperature = Utils.getOrDefault(temperature, 0.7D);
this.topP = topP;
this.stop = stop;
this.maxTokens = maxTokens;
this.presencePenalty = presencePenalty;
this.frequencyPenalty = frequencyPenalty;
this.maxRetries = Utils.getOrDefault(maxRetries, 3);
this.tokenizer = Utils.getOrDefault(tokenizer, new OpenAiTokenizer(this.modelName));
}
public Response<AiMessage> generate(List<ChatMessage> messages) {
return this.generate(messages, null, null);
}
public Response<AiMessage> generate(List<ChatMessage> messages, List<ToolSpecification> toolSpecifications) {
return this.generate(messages, toolSpecifications, null);
}
public Response<AiMessage> generate(List<ChatMessage> messages, ToolSpecification toolSpecification) {
return this.generate(messages, Collections.singletonList(toolSpecification), toolSpecification);
}
private Response<AiMessage> generate(List<ChatMessage> messages,
List<ToolSpecification> toolSpecifications,
ToolSpecification toolThatMustBeExecuted) {
Builder requestBuilder = null;
if (modelName.contains(ChatModel.ZHIPU.toString()) || modelName.contains(ChatModel.ALI.toString())) {
requestBuilder = ChatCompletionRequest.builder()
.model(this.modelName)
.messages(ImproveInternalOpenAiHelper.toOpenAiMessages(messages, this.modelName));
} else {
requestBuilder = ChatCompletionRequest.builder()
.model(this.modelName)
.messages(ImproveInternalOpenAiHelper.toOpenAiMessages(messages, this.modelName))
.temperature(this.temperature).topP(this.topP).stop(this.stop).maxTokens(this.maxTokens)
.presencePenalty(this.presencePenalty).frequencyPenalty(this.frequencyPenalty);
}
if (toolSpecifications != null && !toolSpecifications.isEmpty()) {
requestBuilder.functions(InternalOpenAiHelper.toFunctions(toolSpecifications));
}
if (toolThatMustBeExecuted != null) {
requestBuilder.functionCall(toolThatMustBeExecuted.name());
}
ChatCompletionRequest request = requestBuilder.build();
ChatCompletionResponse response = (ChatCompletionResponse) RetryUtils.withRetry(() -> {
return (ChatCompletionResponse) this.client.chatCompletion(request).execute();
}, this.maxRetries);
return Response.from(InternalOpenAiHelper.aiMessageFrom(response),
InternalOpenAiHelper.tokenUsageFrom(response.usage()),
InternalOpenAiHelper.finishReasonFrom(
((ChatCompletionChoice) response.choices().get(0)).finishReason()));
}
public int estimateTokenCount(List<ChatMessage> messages) {
return this.tokenizer.estimateTokenCountInMessages(messages);
}
public static FullOpenAiChatModel.FullOpenAiChatModelBuilder builder() {
return new FullOpenAiChatModel.FullOpenAiChatModelBuilder();
}
public static class FullOpenAiChatModelBuilder {
private String baseUrl;
private String apiKey;
private String modelName;
private Double temperature;
private Double topP;
private List<String> stop;
private Integer maxTokens;
private Double presencePenalty;
private Double frequencyPenalty;
private Duration timeout;
private Integer maxRetries;
private Proxy proxy;
private Boolean logRequests;
private Boolean logResponses;
private Tokenizer tokenizer;
FullOpenAiChatModelBuilder() {
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder baseUrl(String baseUrl) {
this.baseUrl = baseUrl;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder apiKey(String apiKey) {
this.apiKey = apiKey;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder modelName(String modelName) {
this.modelName = modelName;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder temperature(Double temperature) {
this.temperature = temperature;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder topP(Double topP) {
this.topP = topP;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder stop(List<String> stop) {
this.stop = stop;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder maxTokens(Integer maxTokens) {
this.maxTokens = maxTokens;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder presencePenalty(Double presencePenalty) {
this.presencePenalty = presencePenalty;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder frequencyPenalty(Double frequencyPenalty) {
this.frequencyPenalty = frequencyPenalty;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder timeout(Duration timeout) {
this.timeout = timeout;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder maxRetries(Integer maxRetries) {
this.maxRetries = maxRetries;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder proxy(Proxy proxy) {
this.proxy = proxy;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder logRequests(Boolean logRequests) {
this.logRequests = logRequests;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder logResponses(Boolean logResponses) {
this.logResponses = logResponses;
return this;
}
public FullOpenAiChatModel.FullOpenAiChatModelBuilder tokenizer(Tokenizer tokenizer) {
this.tokenizer = tokenizer;
return this;
}
public FullOpenAiChatModel build() {
return new FullOpenAiChatModel(this.baseUrl, this.apiKey, this.modelName, this.temperature,
this.topP, this.stop, this.maxTokens, this.presencePenalty, this.frequencyPenalty,
this.timeout, this.maxRetries, this.proxy, this.logRequests, this.logResponses, this.tokenizer);
}
public String toString() {
return "FullOpenAiChatModel.FullOpenAiChatModelBuilder(baseUrl=" + this.baseUrl
+ ", apiKey=" + this.apiKey + ", modelName=" + this.modelName + ", temperature="
+ this.temperature + ", topP=" + this.topP + ", stop=" + this.stop + ", maxTokens="
+ this.maxTokens + ", presencePenalty=" + this.presencePenalty + ", frequencyPenalty="
+ this.frequencyPenalty + ", timeout=" + this.timeout + ", maxRetries=" + this.maxRetries
+ ", proxy=" + this.proxy + ", logRequests=" + this.logRequests + ", logResponses="
+ this.logResponses + ", tokenizer=" + this.tokenizer + ")";
}
}
}

66
common/src/main/java/dev/langchain4j/model/openai/ImproveInternalOpenAiHelper.java
View File

@@ -1,66 +0,0 @@
package dev.langchain4j.model.openai;
import dev.ai4j.openai4j.chat.FunctionCall;
import dev.ai4j.openai4j.chat.Message;
import dev.ai4j.openai4j.chat.Role;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.ToolExecutionResultMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.ChatModel;
import java.util.List;
import java.util.stream.Collectors;
public class ImproveInternalOpenAiHelper {
public ImproveInternalOpenAiHelper() {
}
public static List<Message> toOpenAiMessages(List<ChatMessage> messages, String modelName) {
List<Message> messageList = messages.stream()
.map(message -> toOpenAiMessage(message, modelName)).collect(Collectors.toList());
return messageList;
}
public static Message toOpenAiMessage(ChatMessage message, String modelName) {
return Message.builder().role(roleFrom(message, modelName))
.name(nameFrom(message)).content(message.text())
.functionCall(functionCallFrom(message)).build();
}
private static String nameFrom(ChatMessage message) {
if (message instanceof UserMessage) {
return ((UserMessage) message).name();
} else {
return message instanceof ToolExecutionResultMessage
? ((ToolExecutionResultMessage) message).toolName() : null;
}
}
private static FunctionCall functionCallFrom(ChatMessage message) {
if (message instanceof AiMessage) {
AiMessage aiMessage = (AiMessage) message;
if (aiMessage.toolExecutionRequest() != null) {
return FunctionCall.builder().name(aiMessage.toolExecutionRequest().name())
.arguments(aiMessage.toolExecutionRequest().arguments()).build();
}
}
return null;
}
public static Role roleFrom(ChatMessage message, String modelName) {
if (modelName.contains(ChatModel.ZHIPU.toString()) || modelName.contains(ChatModel.ALI.toString())) {
return Role.USER;
}
if (message instanceof AiMessage) {
return Role.ASSISTANT;
} else if (message instanceof ToolExecutionResultMessage) {
return Role.FUNCTION;
} else {
return message instanceof SystemMessage ? Role.SYSTEM : Role.USER;
}
}
}