ClaudeのMessage Batches SDKをPython・TypeScript・Ruby・Javaで実装する

import anthropic
 
client = anthropic.Anthropic()
 
message_batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "ticket-1042",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 512,
                "messages": [
                    {"role": "user", "content": "次の問い合わせに一次回答の下書きを書いてください: 配送が3日遅れています。"}
                ],
            },
        },
        {
            "custom_id": "ticket-1043",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 512,
                "messages": [
                    {"role": "user", "content": "次の問い合わせに一次回答の下書きを書いてください: 返品方法を教えてください。"}
                ],
            },
        },
    ]
)
print(message_batch.id)

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
const messageBatch = await client.messages.batches.create({
  requests: [
    {
      custom_id: "ticket-1042",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 512,
        messages: [{ role: "user", content: "次の問い合わせに一次回答の下書きを書いてください: 配送が3日遅れています。" }]
      }
    },
    {
      custom_id: "ticket-1043",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 512,
        messages: [{ role: "user", content: "次の問い合わせに一次回答の下書きを書いてください: 返品方法を教えてください。" }]
      }
    }
  ]
});
 
console.log(messageBatch.id);

client = Anthropic::Client.new
 
batch = client.messages.batches.create(
  requests: [
    {
      custom_id: "ticket-1042",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 512,
        messages: [
          { role: "user", content: "次の問い合わせに一次回答の下書きを書いてください: 配送が3日遅れています。" }
        ]
      }
    },
    {
      custom_id: "ticket-1043",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 512,
        messages: [
          { role: "user", content: "次の問い合わせに一次回答の下書きを書いてください: 返品方法を教えてください。" }
        ]
      }
    }
  ]
)
 
puts batch.id

AnthropicClient client = AnthropicOkHttpClient.fromEnv();
 
BatchCreateParams params = BatchCreateParams.builder()
  .addRequest(
    BatchCreateParams.Request.builder()
      .customId("ticket-1042")
      .params(
        BatchCreateParams.Request.Params.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(512)
          .addUserMessage("次の問い合わせに一次回答の下書きを書いてください: 配送が3日遅れています。")
          .build()
      )
      .build()
  )
  .addRequest(
    BatchCreateParams.Request.builder()
      .customId("ticket-1043")
      .params(
        BatchCreateParams.Request.Params.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(512)
          .addUserMessage("次の問い合わせに一次回答の下書きを書いてください: 返品方法を教えてください。")
          .build()
      )
      .build()
  )
  .build();
 
MessageBatch messageBatch = client.messages().batches().create(params);
System.out.println(messageBatch.id());

import time
 
while True:
    message_batch = client.messages.batches.retrieve(message_batch.id)
    if message_batch.processing_status == "ended":
        break
    time.sleep(60)
print(message_batch)

let batch = messageBatch;
while (true) {
  batch = await client.messages.batches.retrieve(batch.id);
  if (batch.processing_status === "ended") {
    break;
  }
  await new Promise((resolve) => setTimeout(resolve, 60_000));
}
console.log(batch);

loop do
  batch = client.messages.batches.retrieve(batch.id)
  break if batch.processing_status == :ended
 
  sleep 60
end

import com.anthropic.models.messages.batches.MessageBatch;
 
MessageBatch batch = messageBatch;
while (true) {
    batch = client.messages().batches().retrieve(batch.id());
    if (batch.processingStatus().equals(MessageBatch.ProcessingStatus.ENDED)) {
        break;
    }
    Thread.sleep(60000);
}

for result in client.messages.batches.results(message_batch.id):
    match result.result.type:
        case "succeeded":
            print(f"成功: {result.custom_id}")
        case "errored":
            print(f"エラー: {result.custom_id}")
        case "expired":
            print(f"期限切れ: {result.custom_id}")

for await (const result of await client.messages.batches.results(batch.id)) {
  switch (result.result.type) {
    case "succeeded":
      console.log(`成功: ${result.custom_id}`);
      break;
    case "errored":
      console.log(`エラー: ${result.custom_id}`);
      break;
    case "expired":
      console.log(`期限切れ: ${result.custom_id}`);
      break;
  }
}

client.messages.batches.results_streaming(batch.id).each do |result|
  case result.result
  when Anthropic::Models::Messages::MessageBatchSucceededResult
    puts "成功: #{result.custom_id}"
  when Anthropic::Models::Messages::MessageBatchErroredResult
    puts "エラー: #{result.custom_id}"
  when Anthropic::Models::Messages::MessageBatchExpiredResult
    puts "期限切れ: #{result.custom_id}"
  end
end

import com.anthropic.core.http.StreamResponse;
import com.anthropic.models.messages.batches.BatchResultsParams;
import com.anthropic.models.messages.batches.MessageBatchIndividualResponse;
 
try (
  StreamResponse<MessageBatchIndividualResponse> stream = client
    .messages()
    .batches()
    .resultsStreaming(
      BatchResultsParams.builder().messageBatchId(batch.id()).build()
    )
) {
  stream.stream().forEach(result -> {
    switch (result.result().type().value()) {
      case SUCCEEDED -> System.out.println("成功: " + result.customId());
      case ERRORED -> System.out.println("エラー: " + result.customId());
      case EXPIRED -> System.out.println("期限切れ: " + result.customId());
    }
  });
}