Ultrafast モード | OpenAI API

Ultrafast モードは、OpenAI API で最速のサービスティアです。GPT-6 Astra と GPT-6.1 Sol で広く利用できます。応答時間の短縮が追加コストに見合う場合に使ってください。

WebSocket の利用を強くおすすめします。特に、ツールを短時間に何度も呼び出すエージェント型アプリケーションで効果的です。接続を維持しないと、ネットワークのオーバーヘッドによってレイテンシの短縮効果が小さくなる場合があります。

GPT-6 Astra と GPT-6.1 Sol の Ultrafast モードは、すべての API ユーザーが利用できます。 Ultrafast モードのレート制限は、Standard モードや Fast モードとは別に設定されています。トラフィックを増やす前に、組織に適用される上限を確認してください。組織に OpenAI の担当チームがある場合は、そのチームに上限の引き上げを依頼してください。

リクエストの設定

model を gpt-6-astra または gpt-6.1-sol に、service_tier を ultrafast に設定します。各 response.create イベントでこの設定を指定してください。

接続とレスポンスの作成の手順に従って、使用する言語の SDK と WebSocket 接続に必要な依存パッケージをインストールしてください。サンプルを実行する前に、環境変数 OPENAI_API_KEY を設定してください。

単一の WebSocket 接続で複数のターンにわたって Ultrafast を利用

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53// Install: npm install openai ws
// Set OPENAI_API_KEY in your environment.

import OpenAI from "openai";
import { ResponsesWS } from "openai/resources/responses/ws";

const client = new OpenAI();
const ws = new ResponsesWS(client);

let previousResponseId = null;

try {
  for (const input of [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
  ]) {
    let completed = false;
    const events = ws.stream();

    ws.send({
      type: "response.create",
      model: "gpt-6-astra",
      service_tier: "ultrafast",
      previous_response_id: previousResponseId,
      input,
    });

    for await (const event of events) {
      if (event.type === "error") throw event.error;
      if (event.type !== "message") continue;
      const message = event.message;
      if (message.type === "response.output_text.delta") {
        process.stdout.write(message.delta);
      } else if (message.type === "response.completed") {
        previousResponseId = message.response.id;
        completed = true;
        console.log();
        break;
      } else if (
        message.type === "response.failed" ||
        message.type === "response.incomplete"
      ) {
        throw new Error(JSON.stringify(message));
      }
    }

    if (!completed) {
      throw new Error("Connection closed before the response finished.");
    }
  }
} finally {
  ws.close();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34# Install: pip install --upgrade "openai[realtime]"
# Set OPENAI_API_KEY in your environment.

from openai import OpenAI

client = OpenAI()

previous_response_id: str | None = None
prompts = [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
]

with client.responses.connect() as connection:
    for prompt in prompts:
        connection.response.create(
            model="gpt-6-astra",
            service_tier="ultrafast",
            store=False,  # Keep this conversation on the current connection.
            previous_response_id=previous_response_id,
            input=prompt,
        )

        for event in connection:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                previous_response_id = event.response.id
                print()
                break
            elif event.type in {"response.failed", "response.incomplete", "error"}:
                raise RuntimeError(event.to_json())
        else:
            raise RuntimeError("Connection closed before the response finished.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56package main

import (
	"context"
	"fmt"
	"time"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
	defer cancel()

	client := openai.NewClient()
	conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	previousResponseID := ""

	for _, prompt := range []string{
		"Explain why the sky is blue in one sentence.",
		"Now explain why sunsets look red.",
	} {
		request := responses.ResponsesClientEventResponseCreateParam{
			Model:       "gpt-6-astra",
			ServiceTier: "ultrafast",
			Input: responses.ResponsesClientEventResponseCreateInputUnionParam{
				OfString: openai.String(prompt),
			},
		}
		if previousResponseID != "" {
			request.PreviousResponseID = openai.String(previousResponseID)
		}

		if err := conn.Create(ctx, request); err != nil {
			panic(err)
		}

		// FinalResponse reads events until the response finishes.
		response, err := conn.FinalResponse(ctx)
		if err != nil {
			panic(err)
		}
		if response.Status != responses.ResponseStatusCompleted {
			panic(fmt.Sprintf("Response ended with status %s", response.Status))
		}

		previousResponseID = response.ID
		fmt.Println(response.OutputText())
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseStatus;
import com.openai.models.responses.ResponsesClientEvent;
import java.util.List;

var client = OpenAIOkHttpClient.fromEnv();

try (var connection = client.responses().connect()) {
  String previousResponseId = null;

  for (var prompt :
      List.of(
          "Explain why the sky is blue in one sentence.",
          "Now explain why sunsets look red.")) {
    var request =
        ResponsesClientEvent.ResponseCreate.builder()
            .model("gpt-6-astra")
            .serviceTier(ResponsesClientEvent.ResponseCreate.ServiceTier.ULTRAFAST)
            .input(prompt);
    if (previousResponseId != null) {
      request.previousResponseId(previousResponseId);
    }

    connection.send(ResponsesClientEvent.ofResponseCreate(request.build()));

    var response = connection.finalResponse();
    if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
      throw new IllegalStateException(
          "Response ended with status " + response.status().orElse(null));
    }

    previousResponseId = response.id();
    response.output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
} finally {
  client.close();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41# Install: gem install openai async-websocket
# Set OPENAI_API_KEY in your environment.

require "async"
require "openai"

client = OpenAI::Client.new

request = {
  model: "gpt-6-astra",
  service_tier: :ultrafast
}
prompts = [
  "Explain why the sky is blue in one sentence.",
  "Now explain why sunsets look red."
]

Sync do |task|
  task.with_timeout(120) do
    client.responses.connect(request_options: { timeout: 10 }) do |connection|
      prompts.each do |prompt|
        connection.response.create(**request, input: prompt)

        loop do
          event = connection.receive
          raise "Connection closed before the response finished" unless event

          case event
          when OpenAI::Responses::ResponseCompletedEvent
            request[:previous_response_id] = event.response.id
            puts(event.response.output_text)
            break
          when OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponseIncompleteEvent,
               OpenAI::Responses::ResponsesServerEvent::ResponseWsError
            raise "Response failed: #{event.to_json}"
          end
        end
      end
    end
  end
end

これらのサンプルでは、同じ接続で 2 件のリクエストを送信し、それぞれのレスポンスを表示します。Go、Java、Ruby のサンプルでは、レスポンス全体を受信してから表示します。2 件目のリクエストでは、新しいプロンプトを送信し、最初のレスポンスの ID を previous_response_id として渡します。以降のターンやツールの実行結果の送信にも、同じ接続を使ってください。詳しくは、追加入力による会話の継続を参照してください。

HTTP を使う方法

Ultrafast は、SDK 経由の HTTP リクエストにも対応しています。ツールを頻繁に呼び出すエージェント型アプリケーションでは、WebSocket 接続を維持してリクエスト間のオーバーヘッドを減らしてください。

HTTP 経由での Ultrafast レスポンスの作成

Python

1
2
3
4
5
6
7
8
9
10
11import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  service_tier: "ultrafast",
  input: "Explain why the sky is blue in one sentence.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Explain why the sky is blue in one sentence.",
    service_tier="ultrafast",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:       "gpt-6-astra",
		ServiceTier: responses.ResponseNewParamsServiceTierUltrafast,
		Input:       responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain why the sky is blue in one sentence.")},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Explain why the sky is blue in one sentence.")
        .serviceTier(ResponseCreateParams.ServiceTier.ULTRAFAST)
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  service_tier: :ultrafast,
  input: "Explain why the sky is blue in one sentence."
)

puts(response.output_text)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explain why the sky is blue in one sentence.",
    "service_tier": "ultrafast"
  }'

このサンプルでは、レスポンス全体を受信するまで待ちます。出力を受信した分から順に表示するには、ストリーミングを有効にしてください。

利用条件

GPT-6.1 Sol の Ultrafast モードでは、トークンのレート制限のデフォルト値は次のとおりです。

API 利用ティア	1 分あたりのトークン数（TPM）
Build	1,000,000
Launch	4,000,000
Grow	40,000,000

GPT-6 Astra の Ultrafast モードでは、トークンのレート制限のデフォルト値は次のとおりです。

API 利用ティア	1 分あたりのトークン数（TPM）
Build	500,000
Launch	1,000,000
Grow	5,000,000

入力、キャッシュ済み入力、キャッシュへの書き込み、出力の料金は、Ultrafast の料金表を参照してください。

GPT-6.1 Sol の Ultrafast モードは、米国および EU のデータレジデンシーとグローバル処理に対応しています。GPT-6 Astra の Ultrafast モードが対応しているのは、米国のデータレジデンシーとグローバル処理のみです。

おすすめ

はじめに

基本概念

SDK と CLI

クラウドプロバイダー

リソース

レガシー API

モデルの選び方

テキストとコード

プロンプトの書き方

推論

画像

リアルタイム処理とオーディオ

特化型モデル

Agents API

Agents SDK

ChatKit

検索と情報取得

ツールとデータの接続

ツールを使ったワークフローの構築

コンピューターとコード

メディア

GPT-Live

Realtime API

音声を使った開発

接続

音声処理

本番稼働の開始

パフォーマンスと品質

評価

コストとスループット

安全性とガバナンス

インフラとアクセス

業務運営

基本概念

計画

開発

テストと公開

コンバージョン仕様

ガイド

リソース

アイデンティティ

ChatGPT プランの利用状況

ガイド

ファイルのアップロード

API

効果測定

広告主向け API

API リファレンス

はじめに

はじめに

基礎

探す

対応プラットフォーム

リリース

ワークフロー

できること

Sites

dot

ChatGPT Space

リファレンス

カスタマイズ

設定ファイル

エージェントの設定

ChatGPT と Codex の機能拡張

Linux

Windows

開発ワークフロー

機能拡張と自動化

環境

Codex Cloud

Codex を使った開発

サードパーティ連携

リファレンス

権限

Codex Security

サイバー安全対策

はじめに

機能設定

ID とアクセス管理