> ## Documentation Index
> Fetch the complete documentation index at: https://javaai.pig4cloud.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Bedrock Converse API

[Amazon Bedrock Converse API](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html) 为对话式 AI 模型提供统一接口，具有增强功能，包括函数/工具调用、多模态输入和流式响应。

Bedrock Converse API 具有以下高级功能：

<CardGroup cols={2}>
  <Card title="工具/函数调用" icon="tools">
    支持对话期间的函数定义和工具使用
  </Card>

  <Card title="多模态输入" icon="photo-video">
    能够在对话中处理文本和图像输入
  </Card>

  <Card title="流式支持" icon="stream">
    模型响应的实时流式传输
  </Card>

  <Card title="系统消息" icon="comments">
    支持系统级指令和上下文设置
  </Card>
</CardGroup>

<Tip>
  Bedrock Converse API 在多个模型提供商之间提供统一接口，同时处理特定于 AWS 的身份验证和基础设施问题。
  目前，Converse API [支持的模型](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html)包括：
  `Amazon Titan`、`Amazon Nova`、`AI21 Labs`、`Anthropic Claude`、`Cohere Command`、`Meta Llama`、`Mistral AI`。
</Tip>

<Note>
  根据 Bedrock 的建议，Spring AI 正在过渡到使用 Amazon Bedrock 的 Converse API 来实现 Spring AI 中的所有聊天对话。
  虽然现有的 [InvokeModel API](/spring4ai/api/bedrock-chat) 支持对话应用程序，但我们强烈建议为所有聊天对话模型采用 Converse API。

  Converse API 不支持嵌入操作，因此这些操作将保留在当前 API 中，并且现有 `InvokeModel API` 中的嵌入模型功能将得到维护。
</Note>

## 前提条件

有关设置 API 访问权限，请参阅[Amazon Bedrock 入门](https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html)。

<Steps>
  <Step title="获取 AWS 凭证">
    如果你还没有 AWS 账户和配置好的 AWS CLI，此视频指南可以帮助你进行配置：[不到 4 分钟完成 AWS CLI 和 SDK 设置！](https://youtu.be/gswVHTrRX8I?si=buaY7aeI0l3-bBVb)。你应该能够获取你的访问密钥和安全密钥。
  </Step>

  <Step title="启用要使用的模型">
    转到 [Amazon Bedrock](https://us-east-1.console.aws.amazon.com/bedrock/home) 并从左侧的[模型访问](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess)菜单中，配置对要使用的模型的访问权限。
  </Step>
</Steps>

## 自动配置

<Note>
  Spring AI 自动配置、启动器模块的构件名称发生了重大变化。
  有关更多信息，请参阅[升级说明](https://docs.spring.io/spring-ai/reference/upgrade-notes.html)。
</Note>

将 `spring-ai-starter-model-bedrock-converse` 依赖项添加到项目的 Maven `pom.xml` 或 Gradle `build.gradle` 构建文件中：

<Tabs>
  <Tab title="Maven">
    ```xml theme={"system"}
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-bedrock-converse</artifactId>
    </dependency>
    ```
  </Tab>

  <Tab title="Gradle">
    ```gradle theme={"system"}
    dependencies {
        implementation 'org.springframework.ai:spring-ai-starter-model-bedrock-converse'
    }
    ```
  </Tab>
</Tabs>

<Tip>
  请参阅[依赖管理](/spring4ai/getting-started#dependency-management)部分，将 Spring AI BOM 添加到你的构建文件中。
</Tip>

### 聊天属性

前缀 `spring.ai.bedrock.aws` 是用于配置与 AWS Bedrock 连接的属性前缀。

| 属性                                    | 描述                | 默认值       |
| :------------------------------------ | :---------------- | :-------- |
| `spring.ai.bedrock.aws.region`        | 要使用的 AWS 区域。      | us-east-1 |
| `spring.ai.bedrock.aws.timeout`       | 要使用的 AWS 超时。      | 5m        |
| `spring.ai.bedrock.aws.access-key`    | AWS 访问密钥。         | -         |
| `spring.ai.bedrock.aws.secret-key`    | AWS 秘密密钥。         | -         |
| `spring.ai.bedrock.aws.session-token` | 用于临时凭证的 AWS 会话令牌。 | -         |

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

  要启用，`spring.ai.model.chat=bedrock-converse` (默认启用)

  要禁用，`spring.ai.model.chat=none` (或任何与 bedrock-converse 不匹配的值)

  此更改是为了允许配置多个模型。
</Note>

前缀 `spring.ai.bedrock.converse.chat` 是配置 Converse API 聊天模型实现的属性前缀。

| 属性                                                    | 描述                                                                                                                                      | 默认值                                                                                                                |
| :---------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------- |
| `spring.ai.bedrock.converse.chat.enabled` (已移除)       | 启用 Bedrock Converse 聊天模型。                                                                                                               | true                                                                                                               |
| `spring.ai.model.chat`                                | 启用 Bedrock Converse 聊天模型。                                                                                                               | bedrock-converse                                                                                                   |
| `spring.ai.bedrock.converse.chat.options.model`       | 要使用的模型 ID。你可以使用[支持的模型和模型功能](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html) | 无。从 AWS Bedrock 控制台选择你的 [modelId](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/models)。 |
| `spring.ai.bedrock.converse.chat.options.temperature` | 控制输出的随机性。值范围为 \[0.0,1.0]                                                                                                                | 0.8                                                                                                                |
| `spring.ai.bedrock.converse.chat.options.top-p`       | 采样时要考虑的最大累积概率标记。                                                                                                                        | AWS Bedrock 默认值                                                                                                    |
| `spring.ai.bedrock.converse.chat.options.top-k`       | 用于生成下一个标记的标记选项数。                                                                                                                        | AWS Bedrock 默认值                                                                                                    |
| `spring.ai.bedrock.converse.chat.options.max-tokens`  | 生成响应中的最大标记数。                                                                                                                            | 500                                                                                                                |

## 运行时选项

使用可移植的 `ChatOptions` 或 `ToolCallingChatOptions` 可移植构建器来创建模型配置，例如温度、最大令牌数、topP 等。

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

在运行时，你可以通过向 `Prompt` 调用添加新的、特定于请求的选项来覆盖默认选项：

```java theme={"system"}
var options = ToolCallingChatOptions.builder()
        .model("anthropic.claude-3-5-sonnet-20240620-v1:0")
        .temperature(0.6)
        .maxTokens(300)
        .toolCallbacks(List.of(FunctionToolCallback.builder("getCurrentWeather", new WeatherService())
            .description("获取某个位置的天气。以 36°F 或 36°C 格式返回温度。如果需要，请使用多轮对话。")
            .inputType(WeatherService.Request.class)
            .build()))
        .build();

String response = ChatClient.create(this.chatModel)
    .prompt("阿姆斯特丹现在天气怎么样？")
    .options(options)
    .call()
    .content();
```

## 工具调用

Bedrock Converse API 支持工具调用功能，允许模型在对话期间使用工具。
以下是如何定义和使用基于 @Tool 的工具的示例：

```java theme={"system"}
public class WeatherService {

    @Tool(description = "获取某个位置的天气")
    public String weatherByLocation(@ToolParam(description= "城市或州名") String location) {
        ...
    }
}

String response = ChatClient.create(this.chatModel)
        .prompt("波士顿的天气怎么样？")
        .tools(new WeatherService())
        .call()
        .content();
```

你也可以使用 java.util.function bean 作为工具：

```java theme={"system"}
@Bean
@Description("获取某个位置的天气。以 36°F 或 36°C 格式返回温度。")
public Function<Request, Response> weatherFunction() {
    return new MockWeatherService();
}

String response = ChatClient.create(this.chatModel)
        .prompt("波士顿的天气怎么样？")
        .tools("weatherFunction")
        .inputType(Request.class)
        .call()
        .content();
```

在[工具](/spring4ai/api/tools)文档中查找更多信息。

## 多模态

多模态是指模型同时理解和处理来自各种来源的信息的能力，包括文本、图像、视频、pdf、doc、html、md 和更多数据格式。

Bedrock Converse API 支持多模态输入，包括文本和图像输入，并且可以根据组合输入生成文本响应。

你需要一个支持多模态输入的模型，例如 Anthropic Claude 或 Amazon Nova 模型。

### 图像

对于支持视觉多模态的[模型](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html)（例如 Amazon Nova、Anthropic Claude、Llama 3.2），Bedrock Converse API Amazon 允许你在有效负载中包含多个图像。这些模型可以分析传递的图像并回答问题、对图像进行分类，以及根据提供的说明对图像进行总结。

目前，Bedrock Converse 支持 `image/jpeg`、`image/png`、`image/gif` 和 `image/webp` mime 类型的 `base64` 编码图像。

Spring AI 的 `Message` 接口通过引入 `Media` 类型来支持多模态 AI 模型。
它包含有关消息中媒体附件的数据和信息，使用 Spring 的 `org.springframework.util.MimeType` 和 `java.lang.Object` 来获取原始媒体数据。

以下是一个简单的代码示例，演示了用户文本与图像的组合。

```java theme={"system"}
String response = ChatClient.create(chatModel)
    .prompt()
    .user(u -> u.text("解释一下你在这张图片上看到了什么？")
        .media(Media.Format.IMAGE_PNG, new ClassPathResource("/test.png")))
    .call()
    .content();

logger.info(response);
```

它将 `test.png` 图像作为输入：

<Frame caption="多模态测试图像">
  <img src="https://mintcdn.com/pig/mnE7V5Dtl5t5-aV7/images/multimodal.test.png?fit=max&auto=format&n=mnE7V5Dtl5t5-aV7&q=85&s=45bd6f366290c7559ed4e7af4701d583" width="200" height="200" data-path="images/multimodal.test.png" />
</Frame>

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

```
图片显示了一个装满水果的金属丝水果篮的特写视图。
...
```

### 视频

[Amazon Nova 模型](https://docs.aws.amazon.com/nova/latest/userguide/modalities-video.html)允许你在有效负载中包含单个视频，该视频可以以 base64 格式或通过 Amazon S3 URI 提供。

目前，Bedrock Nova 支持 `video/x-matros`、`video/quicktime`、`video/mp4`、`video/video/webm`、`video/x-flv`、`video/mpeg`、`video/x-ms-wmv` 和 `image/3gpp` mime 类型的图像。

Spring AI 的 `Message` 接口通过引入 `Media` 类型来支持多模态 AI 模型。
它包含有关消息中媒体附件的数据和信息，使用 Spring 的 `org.springframework.util.MimeType` 和 `java.lang.Object` 来获取原始媒体数据。

以下是一个简单的代码示例，演示了用户文本与视频的组合。

```java theme={"system"}
String response = ChatClient.create(chatModel)
    .prompt()
    .user(u -> u.text("解释一下你在这段视频中看到了什么？")
        .media(Media.Format.VIDEO_MP4, new ClassPathResource("/test.video.mp4")))
    .call()
    .content();

logger.info(response);
```

它将 `test.video.mp4` 图像作为输入：

<Frame caption="多模态测试视频">
  <img src="https://mintcdn.com/pig/uheqNCvodstPwu2o/images/test.video.jpeg?fit=max&auto=format&n=uheqNCvodstPwu2o&q=85&s=045d8068f5d4afedd41c0a709ffd3783" width="200" height="200" data-path="images/test.video.jpeg" />
</Frame>

以及文本消息“解释一下你在这段视频中看到了什么？”，并生成如下响应：

```
视频显示一群小鸡，也称为雏鸡，挤在一块表面上
...
```

### 文档

对于某些模型，Bedrock 允许你通过 Converse API 文档支持在有效负载中包含文档，这些文档可以以字节形式提供。
文档支持有两种不同的变体，如下所述：

<CardGroup cols={2}>
  <Card title="文本文档类型" icon="file-alt">
    （txt、csv、html、md 等），重点是文本理解。这些用例包括基于文档的文本元素进行回答。
  </Card>

  <Card title="媒体文档类型" icon="file-image">
    （pdf、docx、xlsx），重点是基于视觉的理解来回答问题。这些用例包括基于图表、图形等回答问题。
  </Card>
</CardGroup>

目前，Anthropic [PDF 支持（测试版）](https://docs.anthropic.com/en/docs/build-with-claude/pdf-support)和 Amazon Bedrock Nova 模型支持文档多模态。

以下是一个简单的代码示例，演示了用户文本与媒体文档的组合。

```java theme={"system"}
String response = ChatClient.create(chatModel)
    .prompt()
    .user(u -> u.text(
            "你是一位非常专业的文档摘要专家。请总结给定的文档。")
        .media(Media.Format.DOC_PDF, new ClassPathResource("/spring-ai-reference-overview.pdf")))
    .call()
    .content();

logger.info(response);
```

它将 `spring-ai-reference-overview.pdf` 文档作为输入：

<Frame caption="多模态测试 PDF">
  <img src="https://mintcdn.com/pig/uheqNCvodstPwu2o/images/test.pdf.png?fit=max&auto=format&n=uheqNCvodstPwu2o&q=85&s=cf7bfc51a61dd2928bf81a1eebb619a7" width="200" height="200" data-path="images/test.pdf.png" />
</Frame>

以及文本消息“你是一位非常专业的文档摘要专家。请总结给定的文档。”，并生成如下响应：

```
**简介：**
- Spring AI 旨在简化具有人工智能 (AI) 功能的应用程序的开发，旨在避免不必要的复杂性。
...
```

## 示例控制器

创建一个新的 Spring Boot 项目，并将 `spring-ai-starter-model-bedrock-converse` 添加到你的依赖项中。

在 `src/main/resources` 下添加一个 `application.properties` 文件：

```properties theme={"system"}
spring.ai.bedrock.aws.region=eu-central-1
spring.ai.bedrock.aws.timeout=10m
spring.ai.bedrock.aws.access-key=${AWS_ACCESS_KEY_ID}
spring.ai.bedrock.aws.secret-key=${AWS_SECRET_ACCESS_KEY}
# 仅临时凭证需要会话令牌
spring.ai.bedrock.aws.session-token=${AWS_SESSION_TOKEN}

spring.ai.bedrock.converse.chat.options.temperature=0.8
spring.ai.bedrock.converse.chat.options.top-k=15
```

以下是使用聊天模型的示例控制器：

```java theme={"system"}
@RestController
public class ChatController {

    private final ChatClient chatClient;

    @Autowired
    public ChatController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @GetMapping("/ai/generate")
    public Map generate(@RequestParam(value = "message", defaultValue = "给我讲个笑话") String message) {
        return Map.of("generation", this.chatClient.prompt(message).call().content());
    }

    @GetMapping("/ai/generateStream")
    public Flux<ChatResponse> generateStream(@RequestParam(value = "message", defaultValue = "给我讲个笑话") String message) {
        return this.chatClient.prompt(message).stream().content();
    }
} 

<Card title="文档有误？请协助编辑" icon="pencil" href="https://github.com/javaai-pig4cloud-com/javaai-docs/edit/main/spring-ai/api/chat/bedrock-converse.mdx">
  发现文档问题？点击此处直接在 GitHub 上编辑并提交 PR，帮助我们改进文档！
</Card>
```
