OpenAI 聊天

Spring AI 支持来自 OpenAI 的各种 AI 语言模型，OpenAI 是 ChatGPT 的创建者，通过创建行业领先的文本生成模型和嵌入，在激发人们对 AI 驱动的文本生成的兴趣方面发挥了重要作用。

前提条件

您需要创建一个 OpenAI API 来访问 ChatGPT 模型。

在 OpenAI 注册页面 创建账户，并在 API Keys 页面 生成令牌。

Spring AI 项目定义了一个名为 spring.ai.openai.api-key 的配置属性，您应该将其设置为从 openai.com 获取的 API Key 值。

您可以在 application.properties 文件中设置此配置属性：

spring.ai.openai.api-key=<your-openai-api-key>

为了增强处理敏感信息（如 API 密钥）时的安全性，您可以使用 Spring 表达式语言（SpEL）来引用自定义环境变量：

# 在 application.yml 中
spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
# 在您的环境或 .env 文件中
export OPENAI_API_KEY=<your-openai-api-key>

您也可以在应用程序代码中以编程方式设置此配置：

// 从安全源或环境变量中检索 API 密钥
String apiKey = System.getenv("OPENAI_API_KEY");

添加仓库和 BOM

Spring AI 构件发布在 Maven Central 和 Spring Snapshot 仓库中。 请参考 构件仓库 部分，将这些仓库添加到您的构建系统中。

为了帮助进行依赖管理，Spring AI 提供了 BOM（物料清单）以确保在整个项目中使用一致版本的 Spring AI。请参考 依赖管理 部分，将 Spring AI BOM 添加到您的构建系统中。

自动配置

Spring AI 自动配置和启动器模块的构件名称发生了重大变化。 请参考 升级说明 了解更多信息。

Spring AI 为 OpenAI 聊天客户端提供 Spring Boot 自动配置。 要启用它，请将以下依赖项添加到项目的 Maven pom.xml 或 Gradle build.gradle 构建文件中：

  • Maven

  • Gradle

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-openai</artifactId>
</dependency>
dependencies {
    implementation 'org.springframework.ai:spring-ai-starter-model-openai'
}

提示：请参考 依赖管理 部分，将 Spring AI BOM 添加到您的构建文件中。

聊天属性

重试属性

前缀 spring.ai.retry 用作属性前缀，允许您配置 OpenAI 聊天模型的重试机制。

属性 描述 默认值

spring.ai.retry.max-attempts

最大重试尝试次数。

10

spring.ai.retry.backoff.initial-interval

指数退避策略的初始睡眠持续时间。

2 秒

spring.ai.retry.backoff.multiplier

退避间隔乘数。

5

spring.ai.retry.backoff.max-interval

最大退避持续时间。

3 分钟

spring.ai.retry.on-client-errors

如果为 false，则抛出 NonTransientAiException，并且不对 4xx 客户端错误代码进行重试

false

spring.ai.retry.exclude-on-http-codes

不应触发重试的 HTTP 状态代码列表（例如，抛出 NonTransientAiException）。

空

spring.ai.retry.on-http-codes

应触发重试的 HTTP 状态代码列表（例如，抛出 TransientAiException）。

空

连接属性

前缀 spring.ai.openai 用作属性前缀，允许您连接到 OpenAI。

属性 描述 默认值

spring.ai.openai.base-url

连接 URL

api.openai.com

spring.ai.openai.api-key

API 密钥

-

spring.ai.openai.organization-id

可选，您可以指定用于 API 请求的组织。

-

spring.ai.openai.project-id

可选，您可以指定用于 API 请求的项目。

-

提示：对于属于多个组织的用户（或通过其旧版用户 API 密钥访问其项目），您可以选择指定用于 API 请求的组织和项目。 这些 API 请求的使用将计入指定组织和项目的使用量。

配置属性

聊天自动配置的启用和禁用现在通过前缀为 spring.ai.model.chat 的顶级属性进行配置。

要启用，spring.ai.model.chat=openai（默认启用）

要禁用，spring.ai.model.chat=none（或任何不匹配 openai 的值）

此更改是为了允许多个模型的配置。

前缀 spring.ai.openai.chat 是属性前缀，允许您配置 OpenAI 的聊天模型实现。

属性 描述 默认值

spring.ai.openai.chat.enabled (已移除且不再有效)

启用 OpenAI 聊天模型。

true

spring.ai.model.chat

启用 OpenAI 聊天模型。

openai

spring.ai.openai.chat.base-url

可选覆盖 spring.ai.openai.base-url 属性以提供聊天特定的 URL。

-

spring.ai.openai.chat.completions-path

要附加到基本 URL 的路径。

/v1/chat/completions

spring.ai.openai.chat.api-key

可选覆盖 spring.ai.openai.api-key 以提供聊天特定的 API 密钥。

-

spring.ai.openai.chat.organization-id

可选，您可以指定用于 API 请求的组织。

-

spring.ai.openai.chat.project-id

可选，您可以指定用于 API 请求的项目。

-

spring.ai.openai.chat.options.model

要使用的 OpenAI 聊天模型的名称。您可以在以下模型之间选择：gpt-4o、gpt-4o-mini、gpt-4-turbo、gpt-3.5-turbo 等。有关更多信息，请参见 模型 页面。

gpt-4o-mini

spring.ai.openai.chat.options.temperature

用于控制生成完成项的明显创造性的采样温度。较高的值将使输出更随机，而较低的值将使结果更集中和确定性。不建议为同一个完成请求同时修改 temperature 和 top_p，因为这两个设置的交互难以预测。

0.8

spring.ai.openai.chat.options.frequencyPenalty

-2.0 到 2.0 之间的数字。正值根据新标记在文本中的现有频率对其进行惩罚，降低模型重复相同行的可能性。

0.0f

spring.ai.openai.chat.options.logitBias

修改指定标记在完成中出现的可能性。

-

spring.ai.openai.chat.options.maxTokens

（已弃用，改用 maxCompletionTokens）聊天完成中生成的最大标记数。输入标记和生成标记的总长度受模型上下文长度的限制。

-

spring.ai.openai.chat.options.maxCompletionTokens

可以为完成生成的标记数量的上限，包括可见输出标记和推理标记。

-

spring.ai.openai.chat.options.n

为每个输入消息生成多少个聊天完成选项。请注意，您将根据所有选项中生成的标记数量收费。将 n 保持为 1 以最小化成本。

1

spring.ai.openai.chat.options.store

是否存储此聊天完成请求的输出以供在我们的模型中使用

false

spring.ai.openai.chat.options.metadata

用于在聊天完成仪表板中过滤完成的开发人员定义的标签和值

空映射

spring.ai.openai.chat.options.output-modalities

您希望模型为此请求生成的输出类型。大多数模型能够生成文本，这是默认值。 gpt-4o-audio-preview 模型也可以用于生成音频。要请求此模型同时生成文本和音频响应， 您可以使用：text、audio。不支持流式传输。

-

spring.ai.openai.chat.options.output-audio

音频生成的音频参数。当通过 output-modalities 请求音频输出时需要：audio。 需要 gpt-4o-audio-preview 模型，并且不支持流式完成。

-

spring.ai.openai.chat.options.presencePenalty

-2.0 到 2.0 之间的数字。正值根据新标记是否出现在文本中对其进行惩罚，增加模型谈论新主题的可能性。

-

spring.ai.openai.chat.options.responseFormat.type

与 GPT-4o、GPT-4o mini、GPT-4 Turbo 和所有比 gpt-3.5-turbo-1106 更新的 GPT-3.5 Turbo 模型兼容。JSON_OBJECT 类型启用 JSON 模式，这保证模型生成的消息是有效的 JSON。 JSON_SCHEMA 类型启用 结构化输出，这保证模型将匹配您提供的 JSON 模式。JSON_SCHEMA 类型还需要设置 responseFormat.schema 属性。

-

spring.ai.openai.chat.options.responseFormat.name

响应格式模式名称。仅适用于 responseFormat.type=JSON_SCHEMA

custom_schema

spring.ai.openai.chat.options.responseFormat.schema

响应格式 JSON 模式。仅适用于 responseFormat.type=JSON_SCHEMA

-

spring.ai.openai.chat.options.responseFormat.strict

响应格式 JSON 模式遵守严格性。仅适用于 responseFormat.type=JSON_SCHEMA

-

spring.ai.openai.chat.options.seed

此功能处于测试阶段。如果指定，我们的系统将尽最大努力进行确定性采样，使得具有相同种子和参数的重复请求应返回相同的结果。

-

spring.ai.openai.chat.options.stop

API 将停止生成更多标记的最多 4 个序列。

-

spring.ai.openai.chat.options.topP

温度采样的替代方案，称为核采样，其中模型考虑具有 top_p 概率质量的标记结果。所以 0.1 意味着只考虑构成前 10% 概率质量的标记。我们通常建议更改此值或 temperature，但不要同时更改两者。

-

spring.ai.openai.chat.options.tools

模型可能调用的工具列表。目前，仅支持函数作为工具。使用此选项提供模型可能为其生成 JSON 输入的函数列表。

-

spring.ai.openai.chat.options.toolChoice

控制模型调用哪个（如果有）函数。none 意味着模型不会调用函数，而是生成消息。auto 意味着模型可以在生成消息或调用函数之间进行选择。通过 {"type: "function", "function": {"name": "my_function"}} 指定特定函数会强制模型调用该函数。当没有函数存在时，none 是默认值。当存在函数时，auto 是默认值。

-

spring.ai.openai.chat.options.user

代表您的最终用户的唯一标识符，可以帮助 OpenAI 监控和检测滥用。

-

spring.ai.openai.chat.options.functions

要在单个提示请求中启用的函数调用函数列表，由其名称标识。具有这些名称的函数必须存在于 functionCallbacks 注册表中。

-

spring.ai.openai.chat.options.stream-usage

（仅用于流式传输）设置为添加一个包含整个请求的标记使用统计信息的额外块。此块的 choices 字段是一个空数组，所有其他块也将包含一个 usage 字段，但值为 null。

false

spring.ai.openai.chat.options.parallel-tool-calls

是否在工具使用期间启用 并行函数调用。

true

spring.ai.openai.chat.options.http-headers

要添加到聊天完成请求的可选 HTTP 头。要覆盖 api-key，您需要使用 Authorization 头键，并且您必须在键值前加上 Bearer 前缀。

-

spring.ai.openai.chat.options.proxy-tool-calls

如果为 true，Spring AI 将不会在内部处理函数调用，而是将它们代理给客户端。然后由客户端负责处理函数调用，将它们分派给适当的函数，并返回结果。如果为 false（默认值），Spring AI 将在内部处理函数调用。仅适用于具有函数调用支持的聊天模型

false

注意：您可以覆盖 ChatModel 和 EmbeddingModel 实现的通用 spring.ai.openai.base-url 和 spring.ai.openai.api-key。 如果设置了 spring.ai.openai.chat.base-url 和 spring.ai.openai.chat.api-key 属性，它们将优先于通用属性。 如果您想为不同的模型和不同的模型端点使用不同的 OpenAI 账户，这很有用。

提示：所有以 spring.ai.openai.chat.options 为前缀的属性都可以通过在 Prompt 调用中添加请求特定的 运行时选项 在运行时被覆盖。

运行时选项

OpenAiChatOptions.java 类提供模型配置，例如要使用的模型、温度、频率惩罚等。

在启动时，可以使用 OpenAiChatModel(api, options) 构造函数或 spring.ai.openai.chat.options.* 属性配置默认选项。

在运行时，您可以通过在 Prompt 调用中添加新的、请求特定的选项来覆盖默认选项。 例如，要覆盖特定请求的默认模型和温度：

ChatResponse response = chatModel.call(
    new Prompt(
        "Generate the names of 5 famous pirates.",
        OpenAiChatOptions.builder()
            .model("gpt-4o")
            .temperature(0.4)
        .build()
    ));

提示：除了模型特定的 OpenAiChatOptions 之外，您还可以使用可移植的 ChatOptions 实例，使用 ChatOptionsBuilder#builder() 创建。

函数调用

您可以使用 OpenAiChatModel 注册自定义 Java 函数，并让 OpenAI 模型智能地选择输出包含调用一个或多个注册函数的参数的 JSON 对象。 这是一种强大的技术，可以将 LLM 功能与外部工具和 API 连接起来。 阅读更多关于 工具调用 的信息。

多模态

多模态性指的是模型同时理解和处理来自各种来源的信息的能力，包括文本、图像、音频和其他数据格式。 OpenAI 支持文本、视觉和音频输入模态。

视觉

提供视觉多模态支持的 OpenAI 模型包括 gpt-4、gpt-4o 和 gpt-4o-mini。 有关更多信息，请参阅 视觉 指南。

OpenAI 用户消息 API 可以在消息中包含 base64 编码的图像或图像 URL 列表。 Spring AI 的 Message 接口通过引入 Media 类型来促进多模态 AI 模型。 此类型包含有关消息中媒体附件的数据和详细信息，使用 Spring 的 org.springframework.util.MimeType 和 org.springframework.core.io.Resource 来获取原始媒体数据。

以下是摘自 OpenAiChatModelIT.java 的代码示例，展示了使用 gpt-4o 模型将用户文本与图像融合：

var imageResource = new ClassPathResource("/multimodal.test.png");

var userMessage = new UserMessage("Explain what do you see on this picture?",
        new Media(MimeTypeUtils.IMAGE_PNG, this.imageResource));

ChatResponse response = chatModel.call(new Prompt(this.userMessage,
        OpenAiChatOptions.builder().model(OpenAiApi.ChatModel.GPT_4_O.getValue()).build()));

提示：GPT_4_VISION_PREVIEW 将继续仅对 2024 年 6 月 17 日开始的此模型的现有用户可用。如果您不是现有用户，请使用 GPT_4_O 或 GPT_4_TURBO 模型。更多详情 在此

或使用 gpt-4o 模型的图像 URL 等效项：

var userMessage = new UserMessage("Explain what do you see on this picture?",
        new Media(MimeTypeUtils.IMAGE_PNG,
                URI.create("https://docs.spring.io/spring-ai/reference/_images/multimodal.test.png")));

ChatResponse response = chatModel.call(new Prompt(this.userMessage,
        OpenAiChatOptions.builder().model(OpenAiApi.ChatModel.GPT_4_O.getValue()).build()));

提示：您也可以传递多个图像。

该示例显示了一个模型将 multimodal.test.png 图像作为输入：

多模态测试图像

以及文本消息"解释您在这张图片上看到什么？"，并生成如下响应：

这是一个水果碗的图像，设计简单。碗由金属制成，带有弯曲的金属丝边缘，
形成一个开放的结构，允许从各个角度看到水果。碗内有两个黄色香蕉，
放在一个红色苹果上面。香蕉稍微过熟，从香蕉皮上的棕色斑点可以看出。
碗顶部有一个金属环，可能用作携带的把手。碗放在一个平面上，
背景为中性色，可以清晰地看到碗内的水果。

音频

提供输入音频多模态支持的 OpenAI 模型包括 gpt-4o-audio-preview。 有关更多信息，请参阅 音频 指南。

OpenAI 用户消息 API 可以在消息中包含 base64 编码的音频文件列表。 Spring AI 的 Message 接口通过引入 Media 类型来促进多模态 AI 模型。 此类型包含有关消息中媒体附件的数据和详细信息，使用 Spring 的 org.springframework.util.MimeType 和 org.springframework.core.io.Resource 来获取原始媒体数据。 目前，OpenAI 仅支持以下媒体类型：audio/mp3 和 audio/wav。

以下是摘自 OpenAiChatModelIT.java 的代码示例，展示了使用 gpt-4o-audio-preview 模型将用户文本与音频文件融合：

var audioResource = new ClassPathResource("speech1.mp3");

var userMessage = new UserMessage("What is this recording about?",
        List.of(new Media(MimeTypeUtils.parseMimeType("audio/mp3"), audioResource)));

ChatResponse response = chatModel.call(new Prompt(List.of(userMessage),
        OpenAiChatOptions.builder().model(OpenAiApi.ChatModel.GPT_4_O_AUDIO_PREVIEW).build()));

提示：您也可以传递多个音频文件。

输出音频

提供输入音频多模态支持的 OpenAI 模型包括 gpt-4o-audio-preview。 有关更多信息，请参阅 音频 指南。

OpenAI 助手消息 API 可以在消息中包含 base64 编码的音频文件列表。 Spring AI 的 Message 接口通过引入 Media 类型来促进多模态 AI 模型。 此类型包含有关消息中媒体附件的数据和详细信息，使用 Spring 的 org.springframework.util.MimeType 和 org.springframework.core.io.Resource 来获取原始媒体数据。 目前，OpenAI 仅支持以下音频类型：audio/mp3 和 audio/wav。

以下是一个代码示例，展示了使用 gpt-4o-audio-preview 模型响应用户文本和音频字节数组：

var userMessage = new UserMessage("Tell me joke about Spring Framework");

ChatResponse response = chatModel.call(new Prompt(List.of(userMessage),
        OpenAiChatOptions.builder()
            .model(OpenAiApi.ChatModel.GPT_4_O_AUDIO_PREVIEW)
            .outputModalities(List.of("text", "audio"))
            .outputAudio(new AudioParameters(Voice.ALLOY, AudioResponseFormat.WAV))
            .build()));

String text = response.getResult().getOutput().getContent(); // 音频转录

byte[] waveAudio = response.getResult().getOutput().getMedia().get(0).getDataAsByteArray(); // 音频数据

您必须在 OpenAiChatOptions 中指定 audio 模态以生成音频输出。 AudioParameters 类提供音频输出的语音和音频格式。

结构化输出

OpenAI 提供自定义 结构化输出 API，确保您的模型生成严格符合您提供的 JSON Schema 的响应。 除了现有的 Spring AI 模型无关的 结构化输出转换器 之外，这些 API 提供了增强的控制和精度。

注意：目前，OpenAI 支持 JSON Schema 语言的子集 格式。

配置

Spring AI 允许您通过 OpenAiChatOptions 构建器以编程方式或通过应用程序属性配置响应格式。

使用聊天选项构建器

您可以使用 OpenAiChatOptions 构建器以编程方式设置响应格式，如下所示：

String jsonSchema = """
        {
            "type": "object",
            "properties": {
                "steps": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "explanation": { "type": "string" },
                            "output": { "type": "string" }
                        },
                        "required": ["explanation", "output"],
                        "additionalProperties": false
                    }
                },
                "final_answer": { "type": "string" }
            },
            "required": ["steps", "final_answer"],
            "additionalProperties": false
        }
        """;

Prompt prompt = new Prompt("how can I solve 8x + 7 = -23",
        OpenAiChatOptions.builder()
            .model(ChatModel.GPT_4_O_MINI)
            .responseFormat(new ResponseFormat(ResponseFormat.Type.JSON_SCHEMA, this.jsonSchema))
            .build());

ChatResponse response = this.openAiChatModel.call(this.prompt);

注意：遵守 OpenAI JSON Schema 语言的子集 格式。

与 BeanOutputConverter 工具集成

您可以利用现有的 BeanOutputConverter 工具自动从您的域对象生成 JSON Schema，并随后将结构化响应转换为域特定的实例：

  • Java

  • Kotlin

record MathReasoning(
    @JsonProperty(required = true, value = "steps") Steps steps,
    @JsonProperty(required = true, value = "final_answer") String finalAnswer) {

    record Steps(
        @JsonProperty(required = true, value = "items") Items[] items) {

        record Items(
            @JsonProperty(required = true, value = "explanation") String explanation,
            @JsonProperty(required = true, value = "output") String output) {
        }
    }
}

var outputConverter = new BeanOutputConverter<>(MathReasoning.class);

var jsonSchema = this.outputConverter.getJsonSchema();

Prompt prompt = new Prompt("how can I solve 8x + 7 = -23",
        OpenAiChatOptions.builder()
            .model(ChatModel.GPT_4_O_MINI)
            .responseFormat(new ResponseFormat(ResponseFormat.Type.JSON_SCHEMA, this.jsonSchema))
            .build());

ChatResponse response = this.openAiChatModel.call(this.prompt);
String content = this.response.getResult().getOutput().getContent();

MathReasoning mathReasoning = this.outputConverter.convert(this.content);
data class MathReasoning(
	val steps: Steps,
	@get:JsonProperty(value = "final_answer") val finalAnswer: String) {

	data class Steps(val items: Array<Items>) {

		data class Items(
			val explanation: String,
			val output: String)
	}
}

val outputConverter = BeanOutputConverter(MathReasoning::class.java)

val jsonSchema = outputConverter.jsonSchema;

val prompt = Prompt("how can I solve 8x + 7 = -23",
	OpenAiChatOptions.builder()
		.model(ChatModel.GPT_4_O_MINI)
		.responseFormat(ResponseFormat(ResponseFormat.Type.JSON_SCHEMA, jsonSchema))
		.build())

val response = openAiChatModel.call(prompt)
val content = response.getResult().getOutput().getContent()

val mathReasoning = outputConverter.convert(content)

注意：虽然这对 JSON Schema 是可选的，但 OpenAI 要求 结构化响应的必填字段才能正常工作。Kotlin 反射用于根据类型的可空性和参数的默认值推断哪些属性是必需的，因此对于大多数用例，不需要 @get:JsonProperty(required = true)。@get:JsonProperty(value = "custom_name") 可用于自定义属性名称。确保使用此 @get: 语法在相关的 getter 上生成注释，请参阅 相关文档。

通过应用程序属性配置

或者，当使用 OpenAI 自动配置时，您可以通过以下应用程序属性配置所需的响应格式：

spring.ai.openai.api-key=YOUR_API_KEY
spring.ai.openai.chat.options.model=gpt-4o-mini

spring.ai.openai.chat.options.response-format.type=JSON_SCHEMA
spring.ai.openai.chat.options.response-format.name=MySchemaName
spring.ai.openai.chat.options.response-format.schema={"type":"object","properties":{"steps":{"type":"array","items":{"type":"object","properties":{"explanation":{"type":"string"},"output":{"type":"string"}},"required":["explanation","output"],"additionalProperties":false}},"final_answer":{"type":"string"}},"required":["steps","final_answer"],"additionalProperties":false}
spring.ai.openai.chat.options.response-format.strict=true

示例控制器

创建 一个新的 Spring Boot 项目，并将 spring-ai-starter-model-openai 添加到您的 pom（或 gradle）依赖项中。

在 src/main/resources 目录下添加一个 application.properties 文件，以启用和配置 OpenAi 聊天模型：

spring.ai.openai.api-key=YOUR_API_KEY
spring.ai.openai.chat.options.model=gpt-4o
spring.ai.openai.chat.options.temperature=0.7

提示：用您的 OpenAI 凭据替换 api-key。

这将创建一个 OpenAiChatModel 实现，您可以将其注入到您的类中。 以下是一个简单的 @RestController 类示例，它使用聊天模型进行文本生成：

@RestController
public class ChatController {

    private final OpenAiChatModel chatModel;

    @Autowired
    public ChatController(OpenAiChatModel chatModel) {
        this.chatModel = chatModel;
    }

    @GetMapping("/ai/generate")
    public Map<String,String> generate(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        return Map.of("generation", this.chatModel.call(message));
    }

    @GetMapping("/ai/generateStream")
	public Flux<ChatResponse> generateStream(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        Prompt prompt = new Prompt(new UserMessage(message));
        return this.chatModel.stream(prompt);
    }
}

手动配置

OpenAiChatModel 实现了 ChatModel 和 StreamingChatModel，并使用 低级 OpenAiApi 客户端 连接到 OpenAI 服务。

将 spring-ai-openai 依赖项添加到项目的 Maven pom.xml 文件中：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai</artifactId>
</dependency>

或添加到您的 Gradle build.gradle 构建文件中。

dependencies {
    implementation 'org.springframework.ai:spring-ai-openai'
}

提示：请参考 依赖管理 部分，将 Spring AI BOM 添加到您的构建文件中。

接下来，创建一个 OpenAiChatModel 并将其用于文本生成：

var openAiApi = OpenAiApi.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .build();
var openAiChatOptions = OpenAiChatOptions.builder()
            .model("gpt-3.5-turbo")
            .temperature(0.4)
            .maxTokens(200)
            .build();
var chatModel = new OpenAiChatModel(this.openAiApi, this.openAiChatOptions);

ChatResponse response = this.chatModel.call(
    new Prompt("Generate the names of 5 famous pirates."));

// 或使用流式响应
Flux<ChatResponse> response = this.chatModel.stream(
    new Prompt("Generate the names of 5 famous pirates."));

OpenAiChatOptions 提供聊天请求的配置信息。 OpenAiApi.Builder 和 OpenAiChatOptions.Builder 分别是 API 客户端和聊天配置的流畅选项构建器。

低级 OpenAiApi 客户端

OpenAiApi 提供了 OpenAI 聊天 API OpenAI 聊天 API 的轻量级 Java 客户端。

以下类图说明了 OpenAiApi 聊天接口和构建块：

OpenAiApi 聊天 API 图

以下是一个简单的代码片段，展示了如何以编程方式使用 API：

OpenAiApi openAiApi = OpenAiApi.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .build();

ChatCompletionMessage chatCompletionMessage =
    new ChatCompletionMessage("Hello world", Role.USER);

// 同步请求
ResponseEntity<ChatCompletion> response = this.openAiApi.chatCompletionEntity(
    new ChatCompletionRequest(List.of(this.chatCompletionMessage), "gpt-3.5-turbo", 0.8, false));

// 流式请求
Flux<ChatCompletionChunk> streamResponse = this.openAiApi.chatCompletionStream(
        new ChatCompletionRequest(List.of(this.chatCompletionMessage), "gpt-3.5-turbo", 0.8, true));

请参阅 OpenAiApi.java 的 JavaDoc 了解更多信息。

低级 API 示例

API 密钥管理

Spring AI 通过 ApiKey 接口及其实现提供灵活的 API 密钥管理。默认实现 SimpleApiKey 适用于大多数用例，但您也可以创建自定义实现以处理更复杂的场景。

默认配置

默认情况下，Spring Boot 自动配置将使用 spring.ai.openai.api-key 属性创建一个 API 密钥 bean：

spring.ai.openai.api-key=your-api-key-here

自定义 API 密钥配置

您可以使用构建器模式创建具有自己的 ApiKey 实现的 OpenAiApi 自定义实例：

ApiKey customApiKey = new ApiKey() {
    @Override
    public String getValue() {
        // 自定义逻辑以检索 API 密钥
        return "your-api-key-here";
    }
};

OpenAiApi openAiApi = OpenAiApi.builder()
    .apiKey(customApiKey)
    .build();

// 使用自定义 OpenAiApi 实例创建聊天客户端
OpenAiChatClient chatClient = new OpenAiChatClient(openAiApi);

这在以下情况下很有用：

  • 从安全密钥存储中检索 API 密钥

  • 动态轮换 API 密钥

  • 实现自定义 API 密钥选择逻辑