Spring AI 第二讲之 Chat Model API 第四节Amazon Bedrock

疼死老夫了

已于 2024-06-04 11:38:59 修改

阅读量1.1k

点赞数 21

文章标签：人工智能 spring java

于 2024-06-03 22:38:24 首次发布

本文链接：https://blog.csdn.net/qq_25137131/article/details/139424431

版权

Amazon Bedrock是一项托管服务，通过统一的应用程序接口提供来自不同人工智能提供商的基础模型。

Spring AI 通过实现 Spring 接口 ChatModel、StreamingChatModel 和 EmbeddingModel，支持亚马逊 Bedrock 提供的所有聊天和嵌入式 AI 模型。
此外，Spring AI 还为所有客户端提供了 Spring Auto-Configurations 和 Boot Starters，使 Bedrock 模型的引导和配置变得非常简单。

入门

有几个步骤可以开始

添加 Boot Starter：将 Bedrock 的 Spring Boot Starter 添加到您的项目中。
获取 AWS 凭据：如果您还没有 AWS 账户和 AWS CLI 配置，本视频指南可以帮助您进行配置： AWS CLI 和 SDK 设置不到 4 分钟！》。您应该能够获得访问密钥和安全密钥。
启用 Bedrock 模型：转到 Amazon Bedrock，从左侧的 "模型访问"菜单配置对要使用的模型的访问。

项目依赖性

然后在项目的 Maven pom.xml 构建文件中添加 Spring Boot Starter 依赖项：

<dependency>
 <artifactId>spring-ai-bedrock-ai-spring-boot-starter</artifactId>
 <groupId>org.springframework.ai</groupId>
</dependency>

或 Gradle build.gradle 构建文件。

dependencies {
    implementation 'org.springframework.ai:spring-ai-bedrock-ai-spring-boot-starter'
}

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

连接至 AWS Bedrock

使用 BedrockAwsConnectionProperties 配置 AWS 凭据和区域：

spring.ai.bedrock.aws.region=us-east-1

spring.ai.bedrock.aws.access-key=YOUR_ACCESS_KEY
spring.ai.bedrock.aws.secret-key=YOUR_SECRET_KEY

spring.ai.bedrock.aws.timeout=10m

区域属性为必填项。
AWS 凭据按以下顺序解析：

Spring-AI Bedrock spring.ai.bedrock.aws.access-key 和 spring.ai.bedrock.aws.secret-key 属性。
Java 系统属性 - aws.accessKeyId 和 aws.secretAccessKey。
环境变量 - AWS_ACCESS_KEY_ID 和 AWS_SECRET_ACCESS_KEY。
系统属性或环境变量中的网络身份令牌凭据。
所有 AWS SDK 和 AWS CLI 共享的默认位置（~/.aws/credentials）上的凭证配置文件。
如果设置了 AWS_CONTAINER_CREDENTIALS_RELATIVE_URI 环境变量，且安全管理器有权限访问该变量，则通过 Amazon EC2 容器服务交付凭证。
通过 Amazon EC2 元数据服务提供的实例配置文件凭证，或设置 AWS_ACCESS_KEY_ID 和 AWS_SECRET_ACCESS_KEY 环境变量。

AWS 区域按以下顺序解析：

Spring-AI Bedrock spring.ai.bedrock.aws.region 属性。
Java 系统属性 - aws.region.
环境变量 - AWS_REGION。
所有 AWS SDK 和 AWS CLI 共享的默认位置（~/.aws/credentials）上的凭证配置文件。
通过亚马逊 EC2 元数据服务交付的实例配置文件区域。

除了标准的 Spring-AI Bedrock 凭据和区域属性配置外，Spring-AI 还提供对自定义 AwsCredentialsProvider 和 AwsRegionProvider Bean 的支持。

注意：例如，同时使用 Spring-AI 和 Spring Cloud for Amazon Web Services。Spring-AI 与 Spring Cloud for Amazon Web Services 的凭证配置兼容。

启用选定的Bedrock模型

注意：默认情况下，所有模型都是禁用的。您必须使用 spring.ai.bedrock.<model>.<chat|embedding>.enabled=true 属性显式启用所选的 Bedrock 模型。

以下是支持的 <model> 和 <chat|embedding> 组合：

Model	Chat	Chat Streaming（流）	Embedding(嵌入)
llama	Yes	Yes	No
jurassic2	Yes	No	No
cohere	Yes	Yes	Yes
anthropic 2	Yes	Yes	No
anthropic 3	Yes	Yes	No
jurassic2 (WIP)	Yes	No	No
titan	Yes	Yes	Yes (however, no batch support)

例如，要启用 Bedrock Llama 聊天模型，需要设置 spring.ai.bedrock.llama.chat.enabled=true。
接下来，你可以使用 spring.ai.bedrock.<model>.<chat|embedding>.* 属性来配置所提供的每个模型。
有关详细信息，请参阅下面每个支持模型的文档。

Spring AI Bedrock Anthropic 2 Chat: spring.ai.bedrock.anthropic.chat.enabled=true
Spring AI Bedrock Anthropic 3 Chat: spring.ai.bedrock.anthropic.chat.enabled=true
Spring AI Bedrock Llama Chat: spring.ai.bedrock.llama.chat.enabled=true
Spring AI Bedrock Cohere Chat: spring.ai.bedrock.cohere.chat.enabled=true
Spring AI Bedrock Cohere Embeddings: spring.ai.bedrock.cohere.embedding.enabled=true
Spring AI Bedrock Titan Chat: spring.ai.bedrock.titan.chat.enabled=true
Spring AI Bedrock Titan Embeddings: spring.ai.bedrock.titan.embedding.enabled=true
Spring AI Bedrock Ai21 Jurassic2 Chat: spring.ai.bedrock.jurassic2.chat.enabled=true

Bedrock Anthropic 3

Anthropic Claude模型是一个基础人工智能模型系列，可用于各种应用。
Anthropic Claude模型具有以下高级功能
200k 代币上下文窗口： Anthropic Claude拥有 20 万个令牌的超大容量，非常适合处理技术文档、代码库和文学作品等应用中的大量信息。
支持的任务 Claude 的多功能性涵盖了总结、问答、趋势预测和文档比较等任务，支持从对话到内容生成的广泛应用。
人工智能安全功能： Claude 以 Anthropic 的安全研究为基础，在交互过程中优先考虑乐于助人、诚实和无害，从而降低了品牌风险，确保人工智能行为负责任。
AWS Bedrock Anthropic 模型页面和 Amazon Bedrock 用户指南包含如何使用 AWS 托管模型的详细信息。

Anthropic 的 Claude 2 和 3 模型也可直接在 Anthropic 自己的云平台上使用。Spring AI 提供专用的 Anthropic Claude 客户端来访问它。

前提条件

有关设置 API 访问，请参阅 Amazon Bedrock 上的 Spring AI 文档。

添加资源库和 BOM

Spring AI 工件发布在 Spring Milestone 和 Snapshot 资源库中。请参阅 "资源库 "部分，将这些资源库添加到您的构建系统中。

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

自动配置

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock-ai-spring-boot-starter 依赖关系：

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-bedrock-ai-spring-boot-starter</artifactId>
</dependency>

或 Gradle build.gradle 构建文件。

dependencies {
    implementation 'org.springframework.ai:spring-ai-bedrock-ai-spring-boot-starter'
}

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中

启用人类学聊天

默认情况下，人类学模型是禁用的。要启用它，请将 spring.ai.bedrock.anthropic3.chat.enabled 属性设置为 true。导出环境变量是设置该配置属性的一种方法：

export SPRING_AI_BEDROCK_ANTHROPIC3_CHAT_ENABLED=true

聊天属性

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

Property	Description	Default
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	WS 密钥。	-

spring.ai.bedrock.anthropic3.chat 前缀是为 Claude 配置聊天模型实现的属性前缀。

Property	Description	Default
spring.ai.bedrock.anthropic3.chat.enable	启用基岩人类学聊天模型。默认已禁用	false
spring.ai.bedrock.anthropic3.chat.model	要使用的模型 ID。支持 anthropic.claude-3-sonnet-20240229-v1:0、anthropic.claude-3-haiku-20240307-v1:0 和传统 anthropic.claude-v2、anthropic.claude-v2:1 及 anthropic.claude-instant-v1 模型的同步和流式响应。	`anthropic.claude-3-sonnet-20240229-v1:0`
spring.ai.bedrock.anthropic3.chat.options.temperature	控制输出的随机性。数值范围为 [0.0,1.0]。	0.8
spring.ai.bedrock.anthropic3.chat.options.top-p	取样时要考虑的最大累计概率。	AWS Bedrock default
spring.ai.bedrock.anthropic3.chat.options.top-k	指定生成器用于生成下一个标记的标记选择数量。	AWS Bedrock default
spring.ai.bedrock.anthropic3.chat.options.stop-sequences	最多可配置生成器识别的四个序列。在停止序列之后，生成器将停止生成更多标记。返回的文本不包含停止序列。	10
spring.ai.bedrock.anthropic3.chat.options.anthropic-version	要使用的生成器版本。	bedrock-2023-05-31
spring.ai.bedrock.anthropic3.chat.options.max-tokens	指定生成的响应中要使用的最大令牌数。请注意，模型可能会在达到此最大值之前停止。此参数仅指定要生成的令牌的绝对最大数量。我们建议将上限设定为 4,000 个代币，以获得最佳性能。	500

有关其他模型 ID，请查看 AnthropicChatModel。支持的值：anthropic.claude-instant-v1、anthropic.claude-v2 和 anthropic.claude-v2:1。模型 ID 值也可以在 AWS Bedrock 文档中找到基础模型 ID。

所有以 spring.ai.bedrock.anthropic3.chat.options 为前缀的属性都可以在运行时重写，方法是在提示调用中添加特定于请求的运行时选项。

运行时选项

Anthropic3ChatOptions.java提供了温度、topK、topP 等模型配置。
启动时，可使用 BedrockAnthropicChatModel(api, options) 构造函数或 spring.ai.bedrock.anthropic3.chat.options.* 属性配置默认选项。
在运行时，你可以通过向提示调用添加新的、针对特定请求的选项来覆盖默认选项。例如，覆盖特定请求的默认温度：

ChatResponse response = chatModel.call(
    new Prompt(
        "Generate the names of 5 famous pirates.",
        Anthropic3ChatOptions.builder()
            .withTemperature(0.4)
        .build()
    ));

除了模型专用的 AnthropicChatOptions外，您还可以使用通过 ChatOptionsBuilder#builder() 创建的便携式 ChatOptions实例。

多模型

多模态是指模型能够同时理解和处理各种来源的信息，包括文本、图像、音频和其他数据格式。这种模式代表了人工智能模型的一大进步。

目前，Anthropic Claude 3 支持 base64 图像源类型，以及图像/jpeg、图像/png、图像/gif 和图像/webp 媒体类型。更多信息请查看视觉指南。

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

下面是从 Anthropic3ChatModelIT.java 中提取的一个简单代码示例，演示了用户文本与图片的结合。

  byte[] imageData = new ClassPathResource("/test.png").getContentAsByteArray();

    var userMessage = new UserMessage("Explain what do you see o this picture?",
            List.of(new Media(MimeTypeUtils.IMAGE_PNG, imageData)));

    ChatResponse response = chatModel.call(new Prompt(List.of(userMessage)));

    assertThat(response.getResult().getOutput().getContent()).contains("bananas", "apple", "basket");

Copie

它的输入是 test.png 图像：

以及文本信息 "请解释一下您在这张图片上看到了什么？

图片显示的是一个铁丝水果篮的特写，里面装着几块水果。
篮子似乎是由细金属丝编织成圆形，并有一个高高的把手。
篮子里有几根黄色的香蕉和几个红色的苹果，也可能是西红柿。
水果鲜艳的颜色与金属丝篮子的金属色调形成鲜明对比。
照片的景深较浅，焦点集中在前景的水果上，而向上延伸的篮子手柄则略显模糊，在背景中营造出悦目的虚化效果。
构图和光线使画面呈现出一种简洁、极简的美感，突出了这个优雅的铁丝篮中水果的自然美和新鲜感。

案例

创建一个新的 Spring Boot 项目，并将 spring-ai-bedrock-ai-spring-boot-starter 添加到 pom（或 gradle）依赖项中。
在 src/main/resources 目录下添加 application.properties 文件，以启用和配置 Anthropic 聊天模型：

spring.ai.bedrock.aws.region=eu-central-1
spring.ai.bedrock.aws.timeout=1000ms
spring.ai.bedrock.aws.access-key=${AWS_ACCESS_KEY_ID}
spring.ai.bedrock.aws.secret-key=${AWS_SECRET_ACCESS_KEY}

spring.ai.bedrock.anthropic3.chat.enabled=true
spring.ai.bedrock.anthropic3.chat.options.temperature=0.8
spring.ai.bedrock.anthropic3.chat.options.top-k=15

将区域、访问密钥和密钥替换为您的 AWS 凭据。

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

@RestController
public class ChatController {

    private final BedrockAnthropic3ChatModel chatModel;

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

    @GetMapping("/ai/generate")
    public Map generate(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        return Map.of("generation", 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 chatModel.stream(prompt);
    }
}

手动配置

BedrockAnthropic3ChatModel实现了 ChatModel 和 StreamingChatModel，并使用 Low-level Anthropic3ChatBedrockApi 客户端连接 Bedrock Anthropic 服务。
在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock 依赖关系：

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

或 Gradle build.gradle 构建文件。

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

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

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

Anthropic3ChatBedrockApi anthropicApi =  new Anthropic3ChatBedrockApi(
    AnthropicChatBedrockApi.AnthropicModel.CLAUDE_V3_SONNET.id(),
    EnvironmentVariableCredentialsProvider.create(),
    Region.US_EAST_1.id(),
    new ObjectMapper(),
    Duration.ofMillis(1000L));

BedrockAnthropic3ChatModel chatModel = new BedrockAnthropic3ChatModel(anthropicApi,
    AnthropicChatOptions.builder()
        .withTemperature(0.6f)
        .withTopK(10)
        .withTopP(0.8f)
        .withMaxTokensToSample(100)
        .withAnthropicVersion(AnthropicChatBedrockApi.DEFAULT_ANTHROPIC_VERSION)
        .build());

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

// Or with streaming responses
Flux<ChatResponse> response = chatModel.stream(
    new Prompt("Generate the names of 5 famous pirates."));

Low-level Anthropic3ChatBedrockApi Client

Anthropic3ChatBedrockApi 是 AWS Bedrock Anthropic Claude 模型之上的轻量级 Java 客户端。

客户端支持 anthropic.claude-3-opus-20240229-v1:0、anthropic.claude-3-sonnet-20240229-v1:0、anthropropic.claude-3-haiku-20240307-v1:0 和传统 anthropic.claude-v2、anthropropic.claude-v2:1 和 anthropic.claude-instant-v1 模型的同步（例如 chatCompletion()）和流（例如 chatCompletionStream()）响应。

下面是如何以编程方式使用 api 的简单片段：

Anthropic3ChatBedrockApi anthropicChatApi = new Anthropic3ChatBedrockApi(
   AnthropicModel.CLAUDE_V2.id(), Region.EU_CENTRAL_1.id(), Duration.ofMillis(1000L));

AnthropicChatRequest request = AnthropicChatRequest
  .builder(String.format(Anthropic3ChatBedrockApi.PROMPT_TEMPLATE, "Name 3 famous pirates"))
  .withTemperature(0.8f)
  .withMaxTokensToSample(300)
  .withTopK(10)
  .build();

// Sync request
AnthropicChatResponse response = anthropicChatApi.chatCompletion(request);

// Streaming request
Flux<AnthropicChatResponse> responseStream = anthropicChatApi.chatCompletionStream(request);
List<AnthropicChatResponse> responses = responseStream.collectList().block();

更多信息请参阅 Anthropic3ChatBedrockApi.java 的 JavaDoc。

Llama Chat

Meta 的 Llama Chat 是大型语言模型 Llama 系列的一部分。它擅长基于对话的应用，参数范围从 70 亿到 700 亿。Llama Chat 利用公共数据集和 100 多万个人类注释，提供上下文感知对话。

LlamaChat 以来自公共数据源的 2 万亿个标记为基础进行训练，为深入对话提供了广泛的知识。严格的测试，包括超过 1,000 个小时的红队测试和超过 1,000 个小时的人工智能测试。

AWS Llama 模型页面和 Amazon Bedrock 用户指南包含有关如何使用 AWS 托管模型的详细信息。

前提条件

有关设置 API 访问，请参阅 Amazon Bedrock 上的 Spring AI 文档。

添加存储库和 BOM

Spring AI 工件发布在 Spring Milestone 和 Snapshot 资源库中。请参阅 "资源库 "部分，将这些资源库添加到您的构建系统中。

自动配置

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock-ai-spring-boot-starter 依赖关系：

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-bedrock-ai-spring-boot-starter</artifactId>
</dependency>

或 Gradle build.gradle 构建文件中。

dependencies {
    implementation 'org.springframework.ai:spring-ai-bedrock-ai-spring-boot-starter'
}

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

启用拉玛聊天支持

默认情况下，贝德洛克骆驼模型是禁用的。要启用它，请将 spring.ai.bedrock.llama.chat.enabled 属性设置为 true。导出环境变量是设置该配置属性的一种方法：

export SPRING_AI_BEDROCK_LLAMA_CHAT_ENABLED=true

聊天属性

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.llama.chat 前缀是配置 Llama 聊天模型实现的属性前缀。

属性	说明	默认值
spring.ai.bedrock.llama.chat.enabled	启用或禁用对 Llama 的支持	假
spring.ai.bedrock.llama.chat.model	要使用的模型 ID（见下文）	meta.llama3-70b-instruct-v1:0
spring.ai.bedrock.llama.chat.options.temperature	控制输出的随机性。取值范围为 [0.0,1.0]（含 0.0）。接近 1.0 的值会产生更多变化的响应，而接近 0.0 的值通常会导致模型产生较少令人惊讶的响应。该值指定后端在调用模型时使用的默认值。	0.7
spring.ai.bedrock.llama.chat.options.top-p	采样时要考虑的标记的最大累积概率。该模型结合使用 Top-k 和 nucleus 采样。核采样会考虑概率总和至少为 topP 的最小标记集。	AWS Bedrock 默认
spring.ai.bedrock.llama.chat.options.max-gen-len	指定生成的响应中使用的最大标记数。一旦生成的文本超过 maxGenLen，模型就会截断响应。	300

请查看 LlamaChatBedrockApi#LlamaChatModel了解其他模型 ID。支持的另一个值是 meta.llama2-13b-chat-v1。模型 ID 值也可以在 AWS Bedrock 文档中找到基本模型 ID。

所有以 spring.ai.bedrock.llama.chat.options 为前缀的属性都可以在运行时重写，方法是在 Prompt 调用中添加特定于请求的运行时选项。

运行时选项

BedrockLlChatOptions.java提供了温度、topK、topP 等模型配置。

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

在运行时，你可以通过向提示调用添加新的、与请求特定的选项来覆盖默认选项。例如，覆盖特定请求的默认温度：

ChatResponse response = chatModel.call(
    new Prompt(
        "Generate the names of 5 famous pirates.",
        BedrockLlamaChatOptions.builder()
            .withTemperature(0.4)
        .build()
    ));

除了特定于模型的 BedrockLlamaChatOptions外，您还可以使用通过 ChatOptionsBuilder#builder() 创建的便携式 ChatOptions实例。

示例控制器

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

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

spring.ai.bedrock.aws.region=eu-central-1
spring.ai.bedrock.aws.timeout=1000ms
spring.ai.bedrock.aws.access-key=${AWS_ACCESS_KEY_ID}
spring.ai.bedrock.aws.secret-key=${AWS_SECRET_ACCESS_KEY}

spring.ai.bedrock.llama.chat.enabled=true
spring.ai.bedrock.llama.chat.options.temperature=0.8

将区域、access-key 和 secret-key 替换为您的 AWS 凭据。

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

@RestController
public class ChatController {

    private final BedrockLlamaChatModel chatModel;

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

    @GetMapping("/ai/generate")
    public Map generate(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        return Map.of("generation", 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 chatModel.stream(prompt);
    }
}

手动配置

BedrockLlamaChatModel实现了 ChatModel 和 StreamingChatModel，并使用 Low-level LlamaChatBedrockApi 客户端连接到 Bedrock Anthropic 服务。

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock 依赖关系：

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

或 Gradle build.gradle 构建文件中。

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

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

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

LlamaChatBedrockApi api = new LlamaChatBedrockApi(LlamaChatModel.LLAMA2_70B_CHAT_V1.id(),
	EnvironmentVariableCredentialsProvider.create(),
	Region.US_EAST_1.id(),
	new ObjectMapper(),
	Duration.ofMillis(1000L));

BedrockLlamaChatModel chatModel = new BedrockLlamaChatModel(api,
    BedrockLlamaChatOptions.builder()
        .withTemperature(0.5f)
        .withMaxGenLen(100)
        .withTopP(0.9f).build());

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

// Or with streaming responses
Flux<ChatResponse> response = chatModel.stream(
    new Prompt("Generate the names of 5 famous pirates."));

Low-level LlamaChatBedrockApi 客户端

LlamaChatBedrockApi是 AWS Bedrock Meta Llama 2 和 Llama 2 聊天模型之上的轻量级 Java 客户端。

下面的类图说明了 LlamaChatBedrockApi 的接口和构建模块：

LlamaChatBedrockApi Class Diagram

LlamaChatBedrockApi 支持 meta.llama3-8b-instruct-v1:0、meta.llama3-70b-instruct-v1:0、meta.llama2-13b-chat-v1 和 meta.llama2-70b-chat-v1 模型的同步（如 chatCompletion()) 和流式（如 chatCompletionStream()）响应。

以下是如何以编程方式使用 api 的简单片段：

LlamaChatBedrockApi llamaChatApi = new LlamaChatBedrockApi(
        LlamaChatModel.LLAMA3_70B_INSTRUCT_V1.id(),
        Region.US_EAST_1.id(),
        Duration.ofMillis(1000L));

LlamaChatRequest request = LlamaChatRequest.builder("Hello, my name is")
		.withTemperature(0.9f)
		.withTopP(0.9f)
		.withMaxGenLen(20)
		.build();

LlamaChatResponse response = llamaChatApi.chatCompletion(request);

// Streaming response
Flux<LlamaChatResponse> responseStream = llamaChatApi.chatCompletionStream(request);
List<LlamaChatResponse> responses = responseStream.collectList().block();

更多信息，请参阅 LlamaChatBedrockApi.java的 JavaDoc。

Cohere Chat

提供 Bedrock Cohere 聊天模型。将生成式人工智能功能集成到可改善业务成果的基本应用程序和工作流中。

AWS Bedrock Cohere 模型页面和Amazon Bedrock 用户指南包含有关如何使用 AWS 托管模型的详细信息。

前提条件

有关设置 API 访问，请参阅 Amazon Bedrock 上的 Spring AI 文档。

添加存储库和 BOM

Spring AI 工件发布在 Spring Milestone 和 Snapshot 存储库中。

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

自动配置

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock-ai-spring-boot-starter 依赖关系：

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-bedrock-ai-spring-boot-starter</artifactId>
</dependency>

或 Gradle build.gradle 构建文件中。

dependencies {
    implementation 'org.springframework.ai:spring-ai-bedrock-ai-spring-boot-starter'
}

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

启用 Cohere 聊天支持

默认情况下，Cohere 模型是禁用的。要启用它，请将 spring.ai.bedrock.cohere.chat.enabled 属性设置为 true。导出环境变量是设置该配置属性的一种方法：

export SPRING_AI_BEDROCK_COHERE_CHAT_ENABLED=true

聊天属性

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.cohere.chat 前缀是配置 Cohere 聊天模型实现的属性前缀。

属性	属性	默认值
spring.ai.bedrock.cohere.chat.enabled	启用或禁用对 Cohere 的支持	假
spring.ai.bedrock.cohere.chat.model	要使用的模型 ID。有关支持的模型，请参阅 CohereChatModel。	cohere.command-text-v14
spring.ai.bedrock.cohere.chat.options.temperature	控制输出的随机性。取值范围为 [0.0,1.0] 。	0.7
spring.ai.bedrock.cohere.chat.options.topP	采样时要考虑的标记的最大累积概率。	AWS Bedrock 默认值
spring.ai.bedrock.cohere.chat.options.topK	指定模型用于生成下一个标记的标记选择数量	AWS Bedrock 默认
spring.ai.bedrock.cohere.chat.options.maxTokens	指定生成的响应中要使用的标记的最大数量。	AWS Bedrock 默认
spring.ai.bedrock.cohere.chat.options.stopSequences	最多配置四个模型可识别的序列。	AWS Bedrock 默认
spring.ai.bedrock.cohere.chat.options.returnLikelihoods	随响应返回的标记可能性。	AWS Bedrock 默认值
spring.ai.bedrock.cohere.chat.options.numGenerations	模型应返回的最大代数。	AWS Bedrock 默认值
spring.ai.bedrock.cohere.chat.options.logitBias	防止模型生成不想要的代币，或激励模型包含想要的代币。	AWS Bedrock 默认值
spring.ai.bedrock.cohere.chat.options.truncate	指定 API 如何处理长度超过最大令牌长度的输入	AWS Bedrock 默认

查看 CohereChatModel了解其他模型 ID。支持的值：cohere.command-light-text-v14 和 cohere.command-text

所有以 spring.ai.bedrock.cohere.chat.options 为前缀的属性都可以通过在 Prompt 调用中添加特定于请求的 Runtime Options 在运行时重写。

运行时选项

BedrockCohereChatOptions.java提供了温度、topK、topP 等模型配置。

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

运行时，您可以通过在提示调用中添加新的、针对特定请求的选项来覆盖默认选项。例如，覆盖特定请求的默认温度：

ChatResponse response = chatModel.call(
    new Prompt(
        "Generate the names of 5 famous pirates.",
        BedrockCohereChatOptions.builder()
            .withTemperature(0.4)
        .build()
    ));

除了特定于模型的 BedrockCohereChatOptions外，您还可以使用通过 ChatOptionsBuilder#builder() 创建的便携式 ChatOptions 实例。

示例控制器

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

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

spring.ai.bedrock.aws.region=eu-central-1
spring.ai.bedrock.aws.timeout=1000ms
spring.ai.bedrock.aws.access-key=${AWS_ACCESS_KEY_ID}
spring.ai.bedrock.aws.secret-key=${AWS_SECRET_ACCESS_KEY}

spring.ai.bedrock.cohere.chat.enabled=true
spring.ai.bedrock.cohere.chat.options.temperature=0.8

将区域、访问密钥和保密密钥替换为您的 AWS 凭据。

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

@RestController
public class ChatController {

    private final BedrockCohereChatModel chatModel;

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

    @GetMapping("/ai/generate")
    public Map generate(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        return Map.of("generation", 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 chatModel.stream(prompt);
    }
}

手动配置

BedrockCohereChatModel实现了 ChatModel 和 StreamingChatModel，并使用Low-level CohereChatBedrockApi Client连接到 Bedrock Cohere 服务。

在项目的 Maven pom.xml 文件中添加 Spring-ai-bedrock 依赖关系：

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

或 Gradle build.gradle 构建文件中。

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

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

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

CohereChatBedrockApi api = new CohereChatBedrockApi(CohereChatModel.COHERE_COMMAND_V14.id(),
		EnvironmentVariableCredentialsProvider.create(),
		Region.US_EAST_1.id(),
		new ObjectMapper(),
		Duration.ofMillis(1000L));

BedrockCohereChatModel chatModel = new BedrockCohereChatModel(api,
	    BedrockCohereChatOptions.builder()
					.withTemperature(0.6f)
					.withTopK(10)
					.withTopP(0.5f)
					.withMaxTokens(678)
					.build()

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

// Or with streaming responses
Flux<ChatResponse> response = chatModel.stream(
    new Prompt("Generate the names of 5 famous pirates."));

Low-level CohereChatBedrockApi 客户端

CohereChatBedrockApi是 AWS Bedrock Cohere Command 模型之上的轻量级 Java 客户端。

下面的类图说明了 CohereChatBedrockApi 的接口和构建模块：

bedrock cohere chat low level api

CohereChatBedrockApi 支持 cohere.command-light-text-v14 和 cohere.command-text-v14 模型的同步（如 chatCompletion()）和流（如 chatCompletionStream()）请求。

下面是如何以编程方式使用 api 的简单片段：

CohereChatBedrockApi cohereChatApi = new CohereChatBedrockApi(
	CohereChatModel.COHERE_COMMAND_V14.id(),
	Region.US_EAST_1.id(),
	Duration.ofMillis(1000L));

var request = CohereChatRequest
	.builder("What is the capital of Bulgaria and what is the size? What it the national anthem?")
	.withStream(false)
	.withTemperature(0.5f)
	.withTopP(0.8f)
	.withTopK(15)
	.withMaxTokens(100)
	.withStopSequences(List.of("END"))
	.withReturnLikelihoods(CohereChatRequest.ReturnLikelihoods.ALL)
	.withNumGenerations(3)
	.withLogitBias(null)
	.withTruncate(Truncate.NONE)
	.build();

CohereChatResponse response = cohereChatApi.chatCompletion(request);

var request = CohereChatRequest
	.builder("What is the capital of Bulgaria and what is the size? What it the national anthem?")
	.withStream(true)
	.withTemperature(0.5f)
	.withTopP(0.8f)
	.withTopK(15)
	.withMaxTokens(100)
	.withStopSequences(List.of("END"))
	.withReturnLikelihoods(CohereChatRequest.ReturnLikelihoods.ALL)
	.withNumGenerations(3)
	.withLogitBias(null)
	.withTruncate(Truncate.NONE)
	.build();

Flux<CohereChatResponse.Generation> responseStream = cohereChatApi.chatCompletionStream(request);
List<CohereChatResponse.Generation> responses = responseStream.collectList().block();

Titan Chat

Amazon Titan 基础模型 (FM) 可通过完全托管的 API 为客户提供大量高性能图像、多模态嵌入和文本模型选择。Amazon Titan 模型由 AWS 创建并在大型数据集上进行预训练，使其成为功能强大的通用模型，用于支持各种用例，同时还支持负责任地使用人工智能。您可以按原样使用它们，也可以使用自己的数据对其进行私人定制。

AWS Bedrock Titan 模型页面和 Amazon Bedrock 用户指南包含有关如何使用 AWS 托管模型的详细信息。

前提条件

有关设置 API 访问，请参阅Amazon Bedrock 上的 Spring AI 文档。

添加存储库和 BOM

Spring AI 工件发布在 Spring Milestone 和 Snapshot 资源库中。请参阅 "资源库 "部分，将这些资源库添加到您的构建系统中。

自动配置

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock-ai-spring-boot-starter 依赖关系：

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-bedrock-ai-spring-boot-starter</artifactId>
</dependency>

或 Gradle build.gradle 构建文件中。

dependencies {
    implementation 'org.springframework.ai:spring-ai-bedrock-ai-spring-boot-starter'
}

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

启用Titan Chat

默认情况下，Titan Chat模型是禁用的。要启用它，请将 spring.ai.bedrock.titan.chat.enabled 属性设置为 true。导出环境变量是设置该配置属性的一种方法：

export SPRING_AI_BEDROCK_TITAN_CHAT_ENABLED=true

聊天属性

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.titan.chat 前缀是配置 Titan 聊天模型实现的属性前缀。

属性	属性	默认值
spring.ai.bedrock.titan.chat.enable	启用贝岩Titan Chat模型。默认禁用	false
spring.ai.bedrock.titan.chat.model	要使用的模型 ID。有关支持的模型，请参阅 TitanChatBedrockApi#TitanChatModel 。	亚马逊.titan-text-lite-v1
spring.ai.bedrock.titan.chat.options.temperature	控制输出的随机性。取值范围为 [0.0,1.0] 。	0.7
spring.ai.bedrock.titan.chat.options.topP	采样时要考虑的标记的最大累积概率。	AWS Bedrock 默认值
spring.ai.bedrock.titan.chat.options.stopSequences	最多配置四个生成器可识别的序列。在停止序列之后，生成器将停止生成更多标记。返回的文本不包含停止序列。	AWS Bedrock 默认
spring.ai.bedrock.titan.chat.options.maxToken	指定生成的响应中要使用的最大令牌数。请注意，模型可能会在达到此最大值之前停止。此参数仅指定要生成的令牌的绝对最大数量。我们建议限制为 4,000 个令牌，以获得最佳性能。	AWS Bedrock 默认值

请查看 TitanChatBedrockApi#TitanChatModel 了解其他模型 ID。支持的值：amazon.titan-text-lite-v1、amazon.titan-text-express-v1 和 amazon.titan-text-premier-v1:0。模型 ID 值也可在 AWS Bedrock 文档中找到，以了解基本模型 ID。

所有以 spring.ai.bedrock.titan.chat.options 为前缀的属性都可以通过在提示调用中添加特定于请求的运行时选项在运行时重写。

运行时选项

BedrockTitanChatOptions.java提供了温度、topP 等模型配置。

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

在运行时，你可以通过向提示调用添加新的、针对特定请求的选项来覆盖默认选项。例如，覆盖特定请求的默认温度：

ChatResponse response = chatModel.call(
    new Prompt(
        "Generate the names of 5 famous pirates.",
        BedrockTitanChatOptions.builder()
            .withTemperature(0.4)
        .build()
    ));

除了特定于模型的 BedrockTitanChatOptions外，你还可以使用通过 ChatOptionsBuilder#builder() 创建的便携式 ChatOptions 实例。

示例控制器

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

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

spring.ai.bedrock.aws.region=eu-central-1
spring.ai.bedrock.aws.timeout=1000ms
spring.ai.bedrock.aws.access-key=${AWS_ACCESS_KEY_ID}
spring.ai.bedrock.aws.secret-key=${AWS_SECRET_ACCESS_KEY}

spring.ai.bedrock.titan.chat.enabled=true
spring.ai.bedrock.titan.chat.options.temperature=0.8

将区域、访问密钥和保密密钥替换为您的 AWS 凭据。

这将创建一个 BedrockTitanChatModel 实现，你可以将其注入到你的类中。下面是一个使用聊天模型生成文本的简单 @Controller 类的示例。

@RestController
public class ChatController {

    private final BedrockTitanChatModel chatModel;

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

    @GetMapping("/ai/generate")
    public Map generate(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        return Map.of("generation", 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 chatModel.stream(prompt);
    }
}

手动配置

BedrockTitanChatModel实现了 ChatModel 和 StreamingChatModel，并使用 Low-level TitanChatBedrockApi 客户端连接 Bedrock Titanic 服务。

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock 依赖关系：

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

或 Gradle build.gradle 构建文件中。

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

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

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

TitanChatBedrockApi titanApi = new TitanChatBedrockApi(
    TitanChatModel.TITAN_TEXT_EXPRESS_V1.id(),
	EnvironmentVariableCredentialsProvider.create(),
    Region.US_EAST_1.id(),
    new ObjectMapper(),
    Duration.ofMillis(1000L));

BedrockTitanChatModel chatModel = new BedrockTitanChatModel(titanApi,
    BedrockTitanChatOptions.builder()
        .withTemperature(0.6f)
        .withTopP(0.8f)
        .withMaxTokenCount(100)
    .build());

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

// Or with streaming responses
Flux<ChatResponse> response = chatModel.stream(
    new Prompt("Generate the names of 5 famous pirates."));

Low-level TitanChatBedrockApi 客户端

TitanChatBedrockApi是 AWS Bedrock Bedrock Titan 模型之上的轻量级 Java 客户端。

下面的类图说明了 TitanChatBedrockApi 的接口和构建模块：

bedrock titan chat low level api

客户端支持同步（如 chatCompletion()）和流（如 chatCompletionStream()）响应的 amazon.titan-text-lite-v1 和 amazon.titan-text-express-v1 模型。

下面是如何以编程方式使用 api 的简单片段：

TitanChatBedrockApi titanBedrockApi = new TitanChatBedrockApi(TitanChatCompletionModel.TITAN_TEXT_EXPRESS_V1.id(),
		Region.EU_CENTRAL_1.id(), Duration.ofMillis(1000L));

TitanChatRequest titanChatRequest = TitanChatRequest.builder("Give me the names of 3 famous pirates?")
	.withTemperature(0.5f)
	.withTopP(0.9f)
	.withMaxTokenCount(100)
	.withStopSequences(List.of("|"))
	.build();

TitanChatResponse response = titanBedrockApi.chatCompletion(titanChatRequest);

Flux<TitanChatResponseChunk> response = titanBedrockApi.chatCompletionStream(titanChatRequest);

List<TitanChatResponseChunk> results = response.collectList().block();

更多信息请参阅 TitanChatBedrockApi的 JavaDoc。

Jurassic-2 Chat

亚马逊 Bedrock 上的 AI21 Labs Jurassic Jurassic 是 AI21 Labs 面向企业的可靠调用工具系列，可在数千个实时应用中执行复杂的语言生成任务，如问题解答、文本生成、搜索和摘要。

前提条件

有关设置 API 访问，请参阅Amazon Bedrock 上的 Spring AI文档。

添加存储库和 BOM

Spring AI 工件发布在 Spring Milestone 和 Snapshot 资源库中。请参阅 Repositories se

自动配置

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock-ai-spring-boot-starter 依赖关系：

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-bedrock-ai-spring-boot-starter</artifactId>
</dependency>

或 Gradle build.gradle 构建文件中。

dependencies {
    implementation 'org.springframework.ai:spring-ai-bedrock-ai-spring-boot-starter'
}

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

启用Jurassic-2 Chat

默认情况下，Bedrock Jurassic-2 模型是禁用的。要启用它，请将 spring.ai.bedrock.jurassic2.chat.enabled 属性设置为 true。导出环境变量是设置该配置属性的一种方法：

export SPRING_AI_BEDROCK_JURASSIC2_CHAT_ENABLED=true

聊天属性

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.jurassic2.chat 是配置 Jurassic-2 聊天模型实现的属性前缀。

属性	属性	默认值
spring.ai.bedrock.jurassic2.chat.enabled	启用或禁用对 Jurassic-2 的支持	假
spring.ai.bedrock.jurassic2.chat.model	要使用的模型 ID（见下文）	ai21.j2-mid-V1
spring.ai.bedrock.jurassic2.chat.options.temperature	控制输出的随机性。取值范围为 [0.0,1.0]（含 0.0）。接近 1.0 的值会产生更多变化的响应，而接近 0.0 的值通常会导致模型产生较少令人惊讶的响应。该值指定后端在调用模型时使用的默认值。	0.7
spring.ai.bedrock.jurassic2.chat.options.top-p	采样时要考虑的标记的最大累积概率。该模型结合使用 Top-k 和 nucleus 采样。核采样会考虑概率总和至少为 topP 的最小标记集。	AWS Bedrock 默认值
spring.ai.bedrock.jurassic2.chat.options.max-tokens	指定生成的回复中要使用的最大标记数。一旦生成的文本超过 maxTokens，模型就会截断响应。	500

请查看 Ai21Jurassic2ChatBedrockApi#Ai21Jurassic2ChatModel 了解其他模型 ID。其他支持的值是 ai21.j2-ultra-v1。模型 ID 值也可以在 AWS Bedrock 文档中找到基本模型 ID。

所有以 spring.ai.bedrock.jurassic2.chat.options 为前缀的属性都可以通过在 Prompt 调用中添加特定于请求的 Runtime Options 在运行时重写。

运行时选项

BedrockAi21Jurassic2ChatOptions.java提供了温度、topP、maxTokens 等模型配置。

启动时，默认选项

在运行时，您可以通过添加新的请求来覆盖默认选项。

ChatResponse response = chatModel.call(
    new Prompt(
        "Generate the names of 5 famous pirates.",
        BedrockAi21Jurassic2ChatOptions.builder()
            .withTemperature(0.4)
        .build()
    ));

除了特定于模型的 BedrockAi21Jurassic2ChatOptions 外，您还可以使用通过 ChatOptionsBuilder#builder()创建的便携式 ChatOptions 实例。

示例控制器

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

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

spring.ai.bedrock.aws.region=eu-central-1
spring.ai.bedrock.aws.timeout=1000ms
spring.ai.bedrock.aws.access-key=${AWS_ACCESS_KEY_ID}
spring.ai.bedrock.aws.secret-key=${AWS_SECRET_ACCESS_KEY}

spring.ai.bedrock.jurassic2.chat.enabled=true
spring.ai.bedrock.jurassic2.chat.options.temperature=0.8

用你的 AWS 凭据替换区域、访问密钥和保密密钥。

这将创建一个 BedrockAi21Jurassic2ChatModel 实现，你可以将其注入到你的类中。下面是一个使用聊天模型生成文本的简单 @Controller 类的示例。

@RestController
public class ChatController {

    private final BedrockAi21Jurassic2ChatModel chatModel;

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

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

}

手动配置

BedrockAi21Jurassic2ChatModel 实现的 ChatModel 使用Low-level客户端连接 Bedrock Jurassic-2 服务。

在项目的 Maven pom.xml 文件中添加 spring-ai-bedrock 依赖关系：

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

或 Gradle build.gradle 构建文件中。

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

请参阅 "依赖关系管理 "部分，将 Spring AI BOM 添加到构建文件中。

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

Ai21Jurassic2ChatBedrockApi api = new Ai21Jurassic2ChatBedrockApi(Ai21Jurassic2ChatModel.AI21_J2_MID_V1.id(),
    EnvironmentVariableCredentialsProvider.create(),
    Region.US_EAST_1.id(),
    new ObjectMapper(),
    Duration.ofMillis(1000L));

BedrockAi21Jurassic2ChatModel chatModel = new BedrockAi21Jurassic2ChatModel(api,
    BedrockAi21Jurassic2ChatOptions.builder()
        .withTemperature(0.5f)
        .withMaxTokens(100)
        .withTopP(0.9f).build());

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

Low-level客户端

Ai21Jurassic2ChatBedrockApi 在 AWS Bedrock Jurassic-2和 Jurassic-2 Chat 模型之上提供了一个轻量级 Java 客户端。

Ai21Jurassic2ChatBedrockApi 支持 ai21.j2-mid-v1 和 ai21.j2-ultra-v1 模型，并且只支持同步（chatCompletion()）。

下面是如何以编程方式使用 API 的简单片段：

Ai21Jurassic2ChatBedrockApi jurassic2ChatApi = new Ai21Jurassic2ChatBedrockApi(
        Ai21Jurassic2ChatModel.AI21_J2_MID_V1.id(),
        Region.US_EAST_1.id(),
        Duration.ofMillis(1000L));

Ai21Jurassic2ChatRequest request = Ai21Jurassic2ChatRequest.builder("Hello, my name is")
        .withTemperature(0.9f)
        .withTopP(0.9f)
        .withMaxTokens(20)
        .build();

Ai21Jurassic2ChatResponse response = jurassic2ChatApi.chatCompletion(request);

更多信息请参阅 Ai21Jurassic2ChatBedrockApi.java 的 JavaDoc。

疼死老夫了

关注

21
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Spring AI 第二讲之 Chat Model API 第四节Amazon Bedrock

是一项托管服务，通过统一的应用程序接口提供来自不同人工智能提供商的基础模型。Spring AI 通过实现 Spring 接口 ChatModel、StreamingChatModel 和 EmbeddingModel，支持亚马逊 Bedrock 提供的。此外，Spring AI 还为所有客户端提供了 Spring Auto-Configurations 和 Boot Starters，使 Bedrock 模型的引导和配置变得非常简单。
复制链接

扫一扫