テキスト生成 | OpenAI API

OpenAI API では、ChatGPT と同じように、大規模言語モデルを使用してプロンプトからテキストを生成できます。モデルは、コード、数式、構造化された JSON データ、人間が書いたような文章など、ほぼあらゆる種類のテキスト応答を生成できます。

このテキスト生成の呼び出しのように、モデルに直接リクエストを送る場合は、Responses API を使用します。

シンプルなプロンプトからのテキスト生成

JavaScript

1
2
3
4
5
6
7
8
9import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: "Write a one-sentence bedtime story about a unicorn.",
});

console.log(response.output_text);

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

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Write a one-sentence bedtime story about a unicorn.",
)

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
23package main

import (
	"context"
	"fmt"

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

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

	resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say this is a test")},
	})
	if err != nil {
		panic(err.Error())
	}

	fmt.Println(resp.OutputText())
}

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

public class Main {
  public static void main(String[] args) {
    OpenAIClient client = OpenAIOkHttpClient.fromEnv();

    ResponseCreateParams params =
        ResponseCreateParams.builder().input("Say this is a test").model("gpt-6-astra").build();

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

1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    "Say 'this is a test.'"
);

Console.WriteLine($"[ASSISTANT]: {response.GetOutputText()}");

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

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-6-astra",
  input: "Write a one-sentence bedtime story about a unicorn."
)

puts(response.output_text)

1
2
3
4
5openai responses create \
  --model "gpt-6-astra" \
  --input "Write a one-sentence bedtime story about a unicorn." \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text'

1
2
3
4
5
6
7curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "input": "Write a one-sentence bedtime story about a unicorn."
    }'

モデルが生成したコンテンツの配列は、レスポンスの output プロパティに格納されます。このシンプルな例では、出力は次の 1 つだけです。

1234567891011121314[
  {
    "id": "msg_67b73f697ba4819183a15cc17d011509",
    "type": "message",
    "role": "assistant",
    "content": [
      {
        "type": "output_text",
        "text": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.",
        "annotations": []
      }
    ]
  }
]

output 配列には複数の項目が含まれることがよくあります。 ツール呼び出し、リーズニングモデルが生成した推論トークンに関するデータなどが含まれる場合があります。モデルのテキスト出力が必ず output[0].content[0].text にあるとは限りません。

一部の公式 SDK では、利便性のためにモデルのレスポンスに output_text プロパティを用意しています。このプロパティは、モデルのすべてのテキスト出力を 1 つの文字列にまとめます。モデルのテキスト出力を手軽に取得したい場合に便利です。

プレーンテキストに加えて、モデルに JSON 形式の構造化データを返させることもできます。この機能を構造化出力と呼びます。

プロンプトエンジニアリング

プロンプトエンジニアリング とは、モデルが要件を満たすコンテンツを安定して生成できるように、効果的な指示を作成することです。

モデルが生成するコンテンツは非決定的であるため、望む出力を得るためのプロンプト作成には、創意工夫と科学的なアプローチの両方が必要です。それでも、手法やベストプラクティスを活用すれば、安定して良い結果を得られます。

メッセージのロールの活用など、どのモデルでも有効なプロンプトエンジニアリングの手法もあります。ただし、最良の結果を得るには、モデルごとにプロンプトを変える必要がある場合があります。同じファミリーのモデルでも、スナップショットが異なると結果が変わることがあります。そのため、より複雑なアプリケーションを構築する際には、次のことを強くお勧めします。

動作の一貫性を保つために、本番環境のアプリケーションで使用するモデルのスナップショットを特定のもの（gpt-5.5-2026-04-23 など）に固定すること
プロンプトの動作を測定するテストと評価スイートを構築し、改良を重ねる際やモデルのバージョンを変更・アップグレードする際に性能を監視できるようにすること

ここからは、プロンプトの作成に使えるツールや手法を見ていきます。

モデルと API の選択

OpenAI では、さまざまなモデルと複数の API から選択できます。gpt-6-astra などのリーズニングモデルは、チャットモデルとは動作が異なり、適したプロンプトも異なります。特に、リーズニングモデルは Responses API と組み合わせることで、より優れた性能と高い知能を発揮します。

テキスト生成アプリを構築する場合は、従来の Chat Completions API よりも Responses API の使用をお勧めします。リーズニングモデルを使用している場合は、Responses への移行が特に有効です。

メッセージのロールと指示への追従

instructions API パラメーターと メッセージのロールを使用すると、権限レベルの異なる指示をモデルに与えることができます。

instructions パラメーターでは、口調、目標、正しい応答の例など、応答を生成する際の振る舞いに関する上位の指示をモデルに与えます。この方法で与えた指示は、input パラメーター内のプロンプトよりも優先されます。

指示を使ったテキスト生成

JavaScript

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",
  reasoning: { effort: "low" },
  instructions: "Talk like a pirate.",
  input: "Are semicolons optional in JavaScript?",
});

console.log(response.output_text);

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

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    instructions="Talk like a pirate.",
    input="Are semicolons optional in JavaScript?",
)

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
24
25
26
27
28
29package 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",
		Instructions: openai.String("Talk like a pirate."),
		Reasoning: responses.ReasoningParam{
			Effort: responses.ReasoningEffortLow,
		},
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Are semicolons optional in JavaScript?"),
		},
	})
	if err != nil {
		panic(err)
	}

	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
23import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.ResponseCreateParams;

String semicolonsDevMsg = "Talk like a pirate.";

String semicolonsPrompt = "Are semicolons optional in JavaScript?";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(semicolonsPrompt)
        .instructions(semicolonsDevMsg)
        .reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
        .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
11
12
13
14
15
16
17
18
19
20
21
22using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions = "Talk like a pirate.",
    ReasoningOptions = new ResponseReasoningOptions
    {
        ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
    },
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

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

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: "Talk like a pirate.",
  reasoning: { effort: :low },
  input: "Are semicolons optional in JavaScript?"
)

puts(response.output_text)

1
2
3
4
5
6
7
8
9curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "reasoning": {"effort": "low"},
        "instructions": "Talk like a pirate.",
        "input": "Are semicolons optional in JavaScript?"
    }'

上の例は、input 配列で次の入力メッセージを使用する場合とほぼ同じです。

異なるロールのメッセージを使ったテキスト生成

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "low" },
  input: [
    {
      role: "developer",
      content: "Talk like a pirate.",
    },
    {
      role: "user",
      content: "Are semicolons optional in JavaScript?",
    },
  ],
});

console.log(response.output_text);

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

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    input=[
        {"role": "developer", "content": "Talk like a pirate."},
        {"role": "user", "content": "Are semicolons optional in JavaScript?"},
    ],
)

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37package 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",
		Reasoning: responses.ReasoningParam{
			Effort: responses.ReasoningEffortLow,
		},
		Input: responses.ResponseNewParamsInputUnion{
			OfInputItemList: responses.ResponseInputParam{
				responses.ResponseInputItemParamOfMessage(
					"Talk like a pirate.",
					responses.EasyInputMessageRoleDeveloper,
				),
				responses.ResponseInputItemParamOfMessage(
					"Are semicolons optional in JavaScript?",
					responses.EasyInputMessageRoleUser,
				),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	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
37import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;

String semicolonsDevMsg = "Talk like a pirate.";

String semicolonsPrompt = "Are semicolons optional in JavaScript?";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(
            ResponseCreateParams.Input.ofResponse(
                List.of(
                    ResponseInputItem.ofEasyInputMessage(
                        EasyInputMessage.builder()
                            .role(EasyInputMessage.Role.DEVELOPER)
                            .content(semicolonsDevMsg)
                            .build()),
                    ResponseInputItem.ofEasyInputMessage(
                        EasyInputMessage.builder()
                            .role(EasyInputMessage.Role.USER)
                            .content(semicolonsPrompt)
                            .build()))))
        .reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
        .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
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    ReasoningOptions = new ResponseReasoningOptions
    {
        ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
    },
};
options.InputItems.Add(
    ResponseItem.CreateDeveloperMessageItem("Talk like a pirate.")
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  reasoning: { effort: :low },
  input: [
    {
      role: :developer,
      content: "Talk like a pirate."
    },
    {
      role: :user,
      content: "Are semicolons optional in JavaScript?"
    }
  ]
)

puts(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "reasoning": {"effort": "low"},
        "input": [
            {
                "role": "developer",
                "content": "Talk like a pirate."
            },
            {
                "role": "user",
                "content": "Are semicolons optional in JavaScript?"
            }
        ]
    }'

instructions パラメーターは、現在の応答生成リクエストにのみ適用されます。previous_response_id パラメーターで会話の状態を管理している場合、以前のターンで使用した instructions はコンテキストに含まれません。

OpenAI Model Spec では、メッセージのロールに応じてモデルがどのように優先順位を付けるかを説明しています。

developer	user	assistant
`developer` メッセージはアプリケーション開発者が与える指示で、 user メッセージよりも優先されます。	`user` メッセージはエンドユーザーが与える指示で、 developer メッセージよりも優先順位が低くなります。	モデルが生成するメッセージのロールは `assistant` です。

複数ターンの会話は、これらの種類のメッセージに加え、ユーザーとモデルの双方が提供するほかの種類のコンテンツで構成される場合があります。詳しくは、会話の状態の管理をご覧ください。

developer メッセージと user メッセージの関係は、プログラミング言語における関数とその引数に例えられます。

developer メッセージは、関数定義のように、システムのルールとビジネスロジックを提供します。
user メッセージは、関数の引数のように、developer メッセージの指示が適用される入力や構成を提供します。

コードでのプロンプトのバージョン管理

再利用可能なプロンプトオブジェクトを作成する代わりに、本番環境のプロンプトをアプリケーションコードに保存します。プロンプトをコードで管理すると、型付き入力、コードレビュー、テスト、通常のデプロイプロセスを活用して、モデルの動作を変更できます。

OpenAI は、API の再利用可能なプロンプトオブジェクトを廃止する予定です。 2026 年 6 月 3 日からプロンプト作成機能を目立たない形にし、v1/prompts は 2026 年 11 月 30 日に停止する予定です。最新のスケジュールは、廃止予定ページでご確認ください。

テキスト生成の機能を新たに開発する場合は、次のようにします。

プロンプトビルダーは、対応する機能の近くにある小さなモジュールにまとめます。
顧客データ、ファイル、タスクのオプションなどの動的な値には、型付きの関数引数やスキーマを使用します。
生成した instructions と input を、Responses API に直接渡します。
本番環境のプロンプトを変更する前に、代表的なフィクスチャ、テスト、評価チェックを追加します。
デプロイシステムを通じてプロンプトの変更を展開し、段階的なリリースが必要な場合は機能フラグや構成を使用します。

既存の連携でプロンプト ID やバージョンを指定して保存済みのプロンプトを呼び出している場合は、プロンプトオブジェクトの移行ガイドに従って、そのプロンプトをコードに移行してください。

次のステップ

テキストの入出力の基本を理解したら、次に以下のリソースを参照してみてください。

Playground でのプロンプト作成

Playground を使用してプロンプトを作成し、改良を重ねます。

構造化出力による JSON データの生成

モデルが出力する JSON データを JSON スキーマに準拠させます。

API リファレンス全体

API リファレンスで、テキスト生成に使用できるすべてのオプションを確認できます。

おすすめ

はじめに

基本コンセプト

SDK と CLI

リソース

レガシー API

モデルの選び方

テキストとコード

プロンプト

推論

画像と動画

リアルタイムと音声

特化型モデル

Agents API

Agents SDK

ChatKit

検索と取得

ツールとデータの接続

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

コンピューターとコード

メディア

GPT-Live

Realtime API

音声を活用した開発

接続

音声処理

本番運用の開始

性能と品質

コストとスループット

安全性とガバナンス

インフラとアクセス

オペレーション

基本コンセプト

Plan

Build

Test and publish

Conversion specs

ガイド

リソース

はじめに

ガイド

File Upload

API

Measurement

Advertiser API

API リファレンス

はじめに

基礎

詳しく見る

利用可能な環境

リリース

ワークフロー

できること

リファレンス

カスタマイズ

設定ファイル

エージェントの構成

ChatGPT と Codex の機能拡張

Linux

Windows

開発ワークフロー

拡張と自動化

環境

Codex を使った開発

サードパーティ連携

リファレンス

権限

Codex Security

サイバーセーフティ

はじめに

ChatGPT Work

ID と認証

ワークスペースのアクセス、ポリシー、モデル

プラグインとコネクタの制御

利用状況、ガバナンス、コンプライアンス

展開とモデルプロバイダー

コミュニティ

ブログ

コミュニティ

ブログ