AWS Claude API

本文按 AWS Bedrock 官方文档整理，完整展示 AWS Bedrock 上 Claude 的 Converse API 与 InvokeModel + Anthropic 风格请求体 两种官方调用方式。

鉴权方式

使用 AWS 凭证进行 SigV4 签名。
运行时服务：bedrock-runtime

请求地址

1. Bedrock Converse API

方法：POST
路径：/model/{modelId}/converse
完整 REST 形态：https://bedrock-runtime.{region}.amazonaws.com/model/{modelId}/converse

2. Bedrock ConverseStream API

方法：POST
路径：/model/{modelId}/converse-stream

3. Bedrock InvokeModel + Anthropic 风格请求体

方法：POST
路径：/model/{modelId}/invoke
完整 REST 形态：https://bedrock-runtime.{region}.amazonaws.com/model/{modelId}/invoke

请求参数

Converse API 请求参数

参数	类型	必填	说明
`modelId`	string	是	Bedrock 模型 ID 或 inference profile ID。
`messages`	array	是	对话消息数组。
`messages[].role`	string	是	`user` 或 `assistant`。
`messages[].content`	array	是	文本、多模态输入等内容块。
`system`	array	否	系统指令数组。
`inferenceConfig.maxTokens`	integer	否	最大输出 token 数。
`inferenceConfig.stopSequences`	array	否	停止序列。
`inferenceConfig.temperature`	number	否	采样温度。
`inferenceConfig.topP`	number	否	nucleus sampling。
`toolConfig`	object	否	工具配置。
`guardrailConfig`	object	否	Guardrail 配置。
`additionalModelRequestFields`	object	否	模型特定扩展字段。
`promptVariables`	object	否	Prompt management 变量。
`requestMetadata`	object	否	请求元数据。

Anthropic 风格请求体参数

参数	类型	必填	说明
`anthropic_version`	string	是	Anthropic 协议版本。
`max_tokens`	integer	是	最大输出 token 数。
`messages`	array	是	Claude 消息数组。
`messages[].role`	string	是	`user` 或 `assistant`。
`messages[].content`	string \| array	是	文本、多模态块、工具结果块。
`system`	string \| array	否	系统提示。
`temperature`	number	否	采样温度。
`top_p`	number	否	nucleus sampling。
`top_k`	integer	否	候选 token 上限。
`stop_sequences`	array	否	停止序列。
`tools`	array	否	工具定义。
`tool_choice`	string \| object	否	工具选择策略。

请求示例

Converse API

curl


aws bedrock-runtime converse \
  --region us-east-1 \
  --model-id anthropic.claude-3-7-sonnet-20250219-v1:0 \
  --messages '[
    {
      "role": "user",
      "content": [
        {
          "text": "Summarize GGPU Platform in one paragraph."
        }
      ]
    }
  ]' \
  --inference-config '{
    "maxTokens": 256,
    "temperature": 0.7
  }'

TypeScript


import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
 
const client = new BedrockRuntimeClient({ region: "us-east-1" });
 
const response = await client.send(
  new ConverseCommand({
    modelId: "anthropic.claude-3-7-sonnet-20250219-v1:0",
    messages: [
      {
        role: "user",
        content: [
          {
            text: "Summarize GGPU Platform in one paragraph.",
          },
        ],
      },
    ],
    inferenceConfig: {
      maxTokens: 256,
      temperature: 0.7,
    },
  }),
);
 
console.log(response);

Python


import boto3
 
client = boto3.client("bedrock-runtime", region_name="us-east-1")
 
response = client.converse(
    modelId="anthropic.claude-3-7-sonnet-20250219-v1:0",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "text": "Summarize GGPU Platform in one paragraph."
                }
            ],
        }
    ],
    inferenceConfig={
        "maxTokens": 256,
        "temperature": 0.7,
    },
)
 
print(response)

Java


import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseRequest;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.InferenceConfiguration;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
 
public class BedrockConverseExample {
  public static void main(String[] args) {
    BedrockRuntimeClient client = BedrockRuntimeClient.builder()
        .region(Region.US_EAST_1)
        .build();
 
    ConverseRequest request = ConverseRequest.builder()
        .modelId("anthropic.claude-3-7-sonnet-20250219-v1:0")
        .messages(
            Message.builder()
                .role("user")
                .content(ContentBlock.builder().text("Summarize GGPU Platform in one paragraph.").build())
                .build()
        )
        .inferenceConfig(
            InferenceConfiguration.builder()
                .maxTokens(256)
                .temperature(0.7F)
                .build()
        )
        .build();
 
    ConverseResponse response = client.converse(request);
    System.out.println(response);
  }
}

Go


package main
 
import (
	"context"
	"fmt"
 
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
)
 
func main() {
	cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRegion("us-east-1"))
	if err != nil {
		panic(err)
	}
 
	client := bedrockruntime.NewFromConfig(cfg)
 
	response, err := client.Converse(context.Background(), &bedrockruntime.ConverseInput{
		ModelId: aws.String("anthropic.claude-3-7-sonnet-20250219-v1:0"),
		Messages: []types.Message{
			{
				Role: types.ConversationRoleUser,
				Content: []types.ContentBlock{
					&types.ContentBlockMemberText{Value: "Summarize GGPU Platform in one paragraph."},
				},
			},
		},
		InferenceConfig: &types.InferenceConfiguration{
			MaxTokens: aws.Int32(256),
			Temperature: aws.Float32(0.7),
		},
	})
	if err != nil {
		panic(err)
	}
 
	fmt.Println(response)
}

Anthropic 风格请求体 + InvokeModel

curl


aws bedrock-runtime invoke-model \
  --region us-east-1 \
  --model-id anthropic.claude-3-7-sonnet-20250219-v1:0 \
  --content-type application/json \
  --accept application/json \
  --body '{
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 256,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Summarize GGPU Platform in one paragraph."
          }
        ]
      }
    ],
    "temperature": 0.7
  }' \
  output.json

TypeScript


import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
 
const client = new BedrockRuntimeClient({ region: "us-east-1" });
 
const response = await client.send(
  new InvokeModelCommand({
    modelId: "anthropic.claude-3-7-sonnet-20250219-v1:0",
    contentType: "application/json",
    accept: "application/json",
    body: JSON.stringify({
      anthropic_version: "bedrock-2023-05-31",
      max_tokens: 256,
      messages: [
        {
          role: "user",
          content: [
            {
              type: "text",
              text: "Summarize GGPU Platform in one paragraph.",
            },
          ],
        },
      ],
      temperature: 0.7,
    }),
  }),
);
 
console.log(new TextDecoder().decode(response.body));

Python


import json
import boto3
 
client = boto3.client("bedrock-runtime", region_name="us-east-1")
 
response = client.invoke_model(
    modelId="anthropic.claude-3-7-sonnet-20250219-v1:0",
    contentType="application/json",
    accept="application/json",
    body=json.dumps(
        {
            "anthropic_version": "bedrock-2023-05-31",
            "max_tokens": 256,
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": "Summarize GGPU Platform in one paragraph.",
                        }
                    ],
                }
            ],
            "temperature": 0.7,
        }
    ),
)
 
print(json.loads(response["body"].read()))

Java


import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelResponse;
 
public class BedrockInvokeModelExample {
  public static void main(String[] args) {
    BedrockRuntimeClient client = BedrockRuntimeClient.builder()
        .region(Region.US_EAST_1)
        .build();
 
    String body = """
      {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 256,
        "messages": [
          {
            "role": "user",
            "content": [
              {
                "type": "text",
                "text": "Summarize GGPU Platform in one paragraph."
              }
            ]
          }
        ],
        "temperature": 0.7
      }
      """;
 
    InvokeModelRequest request = InvokeModelRequest.builder()
        .modelId("anthropic.claude-3-7-sonnet-20250219-v1:0")
        .contentType("application/json")
        .accept("application/json")
        .body(SdkBytes.fromUtf8String(body))
        .build();
 
    InvokeModelResponse response = client.invokeModel(request);
    System.out.println(response.body().asUtf8String());
  }
}

Go


package main
 
import (
	"context"
	"encoding/json"
	"fmt"
 
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
 
func main() {
	cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRegion("us-east-1"))
	if err != nil {
		panic(err)
	}
 
	client := bedrockruntime.NewFromConfig(cfg)
 
	body, _ := json.Marshal(map[string]any{
		"anthropic_version": "bedrock-2023-05-31",
		"max_tokens":        256,
		"messages": []any{
			map[string]any{
				"role": "user",
				"content": []any{
					map[string]any{
						"type": "text",
						"text": "Summarize GGPU Platform in one paragraph.",
					},
				},
			},
		},
		"temperature": 0.7,
	})
 
	response, err := client.InvokeModel(context.Background(), &bedrockruntime.InvokeModelInput{
		ModelId:     aws.String("anthropic.claude-3-7-sonnet-20250219-v1:0"),
		ContentType: aws.String("application/json"),
		Accept:      aws.String("application/json"),
		Body:        body,
	})
	if err != nil {
		panic(err)
	}
 
	fmt.Println(string(response.Body))
}

请求返回结果

Converse API 返回结果

参数	类型	说明
`output.message`	object	输出消息对象。
`output.message.role`	string	通常为 `assistant`。
`output.message.content`	array	输出内容块数组。
`stopReason`	string	停止原因。
`usage.inputTokens`	integer	输入 token 数。
`usage.outputTokens`	integer	输出 token 数。
`usage.totalTokens`	integer	总 token 数。
`metrics.latencyMs`	integer	请求耗时。
`additionalModelResponseFields`	object	模型特定响应字段。

Anthropic 风格返回结果

参数	类型	说明
`id`	string	消息 ID。
`type`	string	通常为 `message`。
`role`	string	通常为 `assistant`。
`content`	array	输出内容块。
`model`	string	实际模型。
`stop_reason`	string	停止原因。
`stop_sequence`	string \| null	命中的停止序列。
`usage.input_tokens`	integer	输入 token 数。
`usage.output_tokens`	integer	输出 token 数。

请求返回示例

Converse API 返回示例


{
  "output": {
    "message": {
      "role": "assistant",
      "content": [
        {
          "text": "GGPU Platform helps teams orchestrate AI workflows through a unified runtime and integration layer."
        }
      ]
    }
  },
  "stopReason": "end_turn",
  "usage": {
    "inputTokens": 14,
    "outputTokens": 18,
    "totalTokens": 32
  },
  "metrics": {
    "latencyMs": 842
  }
}

Anthropic 风格返回示例


{
  "id": "msg_bdrk_01KqZ6mR9L9y7b4Lw6mB9v3",
  "type": "message",
  "role": "assistant",
  "model": "anthropic.claude-3-7-sonnet-20250219-v1:0",
  "content": [
    {
      "type": "text",
      "text": "GGPU Platform helps teams orchestrate AI workflows through a unified runtime and integration layer."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 14,
    "output_tokens": 18
  }
}

说明

Bedrock 上 Claude 主要有两套官方接入方式：Converse 和 InvokeModel + Anthropic 协议请求体。
如果你要写“原生 Claude 风格”文档，通常应展示 InvokeModel 的 body 结构；如果你要写“Bedrock 通用对话接口”文档，应展示 Converse。
更细的多模态 content block、tool use、streaming event 结构请以 AWS 官方文档为准。