テキスト生成 | 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 API への移行が特に有効です。

メッセージのロールと指示の優先順位

モデルに与える指示には優先順位があります。API の instructions パラメータとメッセージのロールを使うと、優先順位の異なる指示を与えられます。

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 日以降はプロンプトオブジェクトの新規作成を積極的に推奨しなくなり、2026 年 11 月 30 日に v1/prompts を停止する予定です。最新のスケジュールは廃止予定のページで確認してください。

テキスト生成機能を新たに開発する際は、次の手順に従ってください。

プロンプトを組み立てるコードは小さなモジュールにまとめ、そのプロンプトを使う機能の近くに配置します。
顧客データ、ファイル、タスクのオプションなど、動的に変わる値には、型付きの関数引数またはスキーマを使います。
生成した instructions と input を Responses API に直接渡します。
本番用のプロンプトを変更する前に、代表的なケースをカバーするテストフィクスチャ、テスト、評価項目を追加します。
プロンプトの変更はデプロイシステムを通じてリリースします。段階的にリリースする場合は、機能フラグや設定を使います。

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

次のステップ

テキストの入出力の基本を学んだら、次のリソースを活用してください。

Playground でのプロンプト作成

Playground でプロンプトを作成し、試しながら改善できます。

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

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

API リファレンス

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

おすすめ

はじめに

基本概念

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 とアクセス管理