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

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 形式の構造化データをモデルに返させることもできます。この機能を構造化出力と呼びます。

Chat Completions API を使った簡単な例を見てみましょう。

簡単なプロンプトからのテキスト生成

JavaScript

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

const completion = await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [
    {
      role: "user",
      content: "Write a one-sentence bedtime story about a unicorn.",
    },
  ],
});

console.log(completion.choices[0].message.content);

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

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": "Write a one-sentence bedtime story about a unicorn.",
        }
    ],
)

print(completion.choices[0].message.content)

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

import (
	"context"
	"fmt"

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

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

	completion, err := client.Chat.Completions.New(
		context.Background(),
		openai.ChatCompletionNewParams{
			Model: "gpt-6-astra",
			Messages: []openai.ChatCompletionMessageParamUnion{
				openai.UserMessage("Write a one-sentence bedtime story about a unicorn."),
			},
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addUserMessage("Write a one-sentence bedtime story about a unicorn.")
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11using OpenAI.Chat;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

ChatCompletion completion = await client.CompleteChatAsync(
    new UserChatMessage("Write a one-sentence bedtime story about a unicorn.")
);

Console.WriteLine(completion.Content[0].Text);

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

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: "Write a one-sentence bedtime story about a unicorn."
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.5",
        "messages": [
            {
                "role": "user",
                "content": "Write a one-sentence bedtime story about a unicorn."
            }
        ]
    }'

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

123456789101112[
  {
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.",
      "refusal": null
    },
    "logprobs": null,
    "finish_reason": "stop"
  }
]

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

モデルの選び方

API でコンテンツを生成する際は、どのモデルを使うかが重要です。上のコード例では model パラメータで指定しています。利用可能なモデルの一覧を参照してください。テキスト生成用のモデルを選ぶ際は、次の点を考慮します。

リーズニングモデル は、内部で思考の連鎖を生成して入力プロンプトを分析します。複雑なタスクの理解や、複数のステップにわたる計画の立案が得意です。一般に、GPT モデルよりも応答に時間がかかり、利用コストも高くなります。
GPT モデルは高速でコスト効率が良く、高い能力を備えています。タスクの進め方を具体的に指示すると、より良い結果が得られます。
大型モデルと小型モデル（mini または nano） では、速度、コスト、能力のバランスが異なります。大型モデルはプロンプトの理解や幅広い分野での問題解決に優れています。一方、小型モデルは一般に高速で、利用コストを抑えられます。

どれを選ぶか迷ったら、汎用的なテキスト生成やプロンプトの試行錯誤には gpt-6-astra が適しています。

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

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

モデルの出力は非決定的で、同じ入力でも結果が変わることがあります。そのため、狙いどおりの出力を得るには、体系的な手法と試行錯誤の両方が必要です。実績のある手法やベストプラクティスを取り入れると、良い結果を安定して得やすくなります。

メッセージのロールを使い分けるなど、どのモデルでも使える手法があります。一方、リーズニングモデルと GPT モデルのように、モデルの種類によっては、最良の結果を得るために指示の出し方を変える必要があります。同じ系列のモデルでも、スナップショットが異なれば結果が変わることがあります。そのため、より複雑なアプリケーションを開発する際は、次の対応を強く推奨します。

本番アプリケーションで使用するモデルのスナップショットを特定のバージョン（例：gpt-4.1-2025-04-14）に固定し、動作の一貫性を確保する
プロンプトの挙動を測定するテストと評価スイートを用意し、プロンプトの改善時やモデルのバージョン変更・アップグレード時に性能を追跡できるようにする

ここからは、プロンプトを組み立てるためのツールと手法を見ていきます。

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

モデルに優先順位の異なる指示を与えるには、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 はコンテキストに含まれません。

モデルに優先順位の異なる指示（プロンプト）を与えるには、メッセージのロールを使います。

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

JavaScript

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

const completion = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "developer",
      content: "Talk like a pirate.",
    },
    {
      role: "user",
      content: "Are semicolons optional in JavaScript?",
    },
  ],
});

console.log(completion.choices[0].message);

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

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-6-astra",
    reasoning_effort="low",
    messages=[
        {"role": "developer", "content": "Talk like a pirate."},
        {"role": "user", "content": "Are semicolons optional in JavaScript?"},
    ],
)

print(completion.choices[0].message.content)

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

import (
	"context"
	"fmt"

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

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

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.DeveloperMessage("Talk like a pirate."),
			openai.UserMessage("Are semicolons optional in JavaScript?"),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

String semicolonsDevMsg = "Talk like a pirate.";

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

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addDeveloperMessage(semicolonsDevMsg)
        .addUserMessage(semicolonsPrompt)
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

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

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

ChatCompletion completion = await client.CompleteChatAsync(
    [
        new DeveloperChatMessage("Talk like a pirate."),
        new UserChatMessage("Are semicolons optional in JavaScript?"),
    ]
);

Console.WriteLine(completion.Content[0].Text);

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

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :developer,
      content: "Talk like a pirate."
    },
    {
      role: :user,
      content: "Are semicolons optional in JavaScript?"
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

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

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 やバージョンを指定して保存済みのプロンプトを呼び出している場合は、プロンプトオブジェクトの移行ガイドに沿って、そのプロンプトをコードに移してください。

Markdown と XML によるメッセージの書式設定

developer メッセージや user メッセージを書く際に、Markdown の書式と XML タグを組み合わせると、プロンプトやコンテキストデータの論理的な区切りがモデルに伝わりやすくなります。

Markdown の見出しやリストを使うと、プロンプトの各セクションを区別し、階層構造をモデルに示せます。開発者にとってもプロンプトが読みやすくなります。XML タグは、参考資料など、ひとまとまりのコンテンツの始まりと終わりを明示するのに役立ちます。XML 属性でプロンプト内のコンテンツにメタデータを付け、指示の中で参照することもできます。

開発者メッセージには通常、次のセクションをこの順序で含めます。ただし、最適な内容や順序は、使用するモデルによって変わることがあります。

役割： アシスタントの用途、コミュニケーションのスタイル、全体の目標を示します。
指示： 望ましい応答を生成する方法をモデルに伝えます。守るべきルール、行うべきこと、決して行ってはならないことを明示します。用途に応じて、カスタム関数の呼び出し方などを個別のサブセクションに分けて説明できます。
例：想定される入力と、それに対してモデルに期待する出力を対にして示します。
コンテキスト： 学習データに含まれない非公開データや独自データ、タスクとの関連性が特に高いとわかっているデータなど、応答の生成に必要な追加情報を渡します。生成リクエストごとに異なるコンテキストを含めることがあるため、通常はプロンプトの末尾付近に置くのが適しています。

次の例では、Markdown と XML タグを使い、developer メッセージをセクションに分けて、指示を補足する例を加えています。

コード生成用の開発者メッセージ

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

You are coding assistant that helps enforce the use of snake case
variables in JavaScript code, and writing code that will run in
Internet Explorer version 6.

# Instructions

* When defining variables, use snake case names (e.g. my_variable)
  instead of camel case names (e.g. myVariable).
* To support old browsers, declare variables using the older
  "var" keyword.
* Do not give responses with Markdown formatting, just return
  the code as requested.

# Examples

<user_query>
How do I declare a string variable for a first name?
</user_query>

<assistant_response>
var first_name = "Anna";
</assistant_response>

API 経由でコード生成用プロンプトを送信

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13import fs from "fs/promises";
import OpenAI from "openai";
const client = new OpenAI();

const instructions = await fs.readFile("fixtures/prompt.txt", "utf-8");

const response = await client.responses.create({
  model: "gpt-6-astra",
  instructions,
  input: "How would I declare a variable for a last name?",
});

console.log(response.output_text);

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

client = OpenAI()

with open("prompt.txt", "r", encoding="utf-8") as f:
    instructions = f.read()

response = client.responses.create(
    model="gpt-6-astra",
    instructions=instructions,
    input="How would I declare a variable for a last name?",
)

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

import (
	"context"
	"fmt"
	"os"

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

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

	instructions, err := os.ReadFile("prompt.txt")
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:        "gpt-6-astra",
		Instructions: openai.String(string(instructions)),
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("How would I declare a variable for a last name?"),
		},
	})
	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
17import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .instructions(
            "You are a coding assistant. Answer with concise JavaScript examples and use semicolons.")
        .input("How would I declare a variable for a last name?")
        .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
18using OpenAI.Responses;
#pragma warning disable OPENAI001

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

string instructions = await File.ReadAllTextAsync("prompt.txt");
CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions = instructions,
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("How would I declare a variable for a last name?")
);

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
instructions = File.read(File.join(__dir__, "prompt.txt"))
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: instructions,
  input: "How would I declare a variable for a last name?"
)

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",
    "instructions": "'"$(< prompt.txt)"'",
    "input": "How would I declare a variable for a last name?"
  }'

プロンプトキャッシュによるコストとレイテンシの削減

メッセージを組み立てる際は、API リクエストで繰り返し使う予定の内容をプロンプトの先頭に置きます。さらに、Chat Completions または Responses に渡す JSON リクエストボディでも、その内容を含む API パラメータを先頭付近に置くようにしてください。こうすると、プロンプトキャッシュによるコストとレイテンシの削減効果を最大限に引き出せます。

フューショット学習

フューショット学習では、プロンプトに少数の入出力例を含めることで、大規模言語モデルをファインチューニングせずに、新しいタスクの進め方を示せます。モデルは例からパターンを読み取り、それをプロンプトに適用します。例を用意する際は、さまざまな入力を取り上げ、それぞれに期待する出力を示してください。

通常、例は API リクエストの developer メッセージに含めます。次の developer メッセージでは、製品やカスタマーサービスに関するレビューを、肯定的、否定的、中立のいずれかに分類する方法を例で示しています。

# 役割

あなたは、短い製品レビューに「Positive」「Negative」「Neutral」のいずれかのラベルを付けるアシスタントです。

# 指示

* 回答には単語を 1 つだけ出力してください。書式や補足説明は加えないでください。
* 製品レビューに表れている感情に応じて、「Positive」「Negative」「Neutral」のいずれか 1 語だけを返してください。

# 例

<product_review id="example-1">
このヘッドホン、本当に気に入っています。音質が抜群です！
</product_review>

<assistant_response id="example-1">
Positive
</assistant_response>

<product_review id="example-2">
バッテリーの持ちはまずまずですが、イヤーパッドは安っぽく感じます。
</product_review>

<assistant_response id="example-2">
Neutral
</assistant_response>

<product_review id="example-3">
カスタマーサービスの対応がひどかったです。もう二度とここでは買いません。
</product_review>

<assistant_response id="example-3">
Negative
</assistant_response>

現行モデル向けのプロンプト設計

gpt-6-astra などの GPT モデルでは、タスクの遂行に必要なロジックとデータをプロンプトに明示し、具体的に指示すると効果的です。最新モデルの能力を引き出すには、まず現行のプロンプトガイドを参照してください。

GPT-6 Astra prompting guide

最新モデルの能力を引き出すプロンプトの書き方を、最新の指針、実践例、移行時の注意点とともに紹介します。

リーズニングモデル向けのプロンプト設計

リーズニングモデルと GPT モデルでは、効果的な指示の出し方が異なります。一般に、リーズニングモデルでは、大まかな方針だけを示したほうが良い結果が得られます。一方、GPT モデルでは、具体的で正確な指示が効果的です。

リーズニングモデルと GPT モデルの違いは、次のように考えることができます。

リーズニングモデルは、経験豊富な同僚に似ています。達成したい目標を伝えれば、具体的な進め方は任せられます。
GPT モデルは、経験の浅い同僚に似ています。作ってほしい成果物を具体的に示し、明確な指示を与えると、最も力を発揮します。

リーズニングモデルを使う際のベストプラクティスについて詳しくは、こちらのガイドを参照してください。

次のステップ

テキストの入出力の基本を押さえたら、目的に応じて次のリソースを活用してください。

Playground でのプロンプト作成

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

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

モデルが出力する JSON データを指定の JSON スキーマに準拠させる方法を説明します。

API リファレンス

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

その他のリソース

プロンプト設計のヒントをさらに探すには、OpenAI Cookbook を参照してください。サンプルコードのほか、次のような外部リソースへのリンクも掲載しています。

おすすめ

はじめに

基本概念

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