텍스트 생성 | 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 속성에는 모델이 생성한 콘텐츠가 배열로 담깁니다. 이 예시에서는 출력 항목이 하나뿐이며 내용은 다음과 같습니다.

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 속성을 제공합니다. 이 속성은 모델이 출력한 모든 텍스트를 하나의 문자열로 합치므로 텍스트 출력에 간편하게 접근할 수 있습니다.

일반 텍스트 외에도 모델이 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 모델 사양에서는 모델이 메시지 역할에 따라 우선순위를 어떻게 정하는지 설명합니다.

developer	user	assistant
`developer` 메시지는 애플리케이션 개발자가 제공하는 지침으로, 사용자 메시지보다 우선합니다.	`user` 메시지는 최종 사용자가 제공하는 지침으로, 개발자 메시지보다 우선순위가 낮습니다.	모델이 생성한 메시지의 역할은 `assistant`입니다.

여러 턴에 걸친 대화에는 이러한 유형의 메시지가 여러 개 포함될 수 있으며, 개발자와 모델이 제공하는 다른 유형의 콘텐츠도 함께 들어갈 수 있습니다. 자세한 내용은 대화 상태 관리 가이드를 참고하세요.

developer 메시지와 user 메시지의 관계는 프로그래밍 언어에서 함수와 인수의 관계에 비유할 수 있습니다.

developer 메시지는 함수 정의처럼 시스템의 규칙과 비즈니스 로직을 제공합니다.
user 메시지는 함수에 전달하는 인수처럼 developer 메시지의 지침을 적용할 입력과 설정을 제공합니다.

코드에서 프롬프트 버전 관리하기

재사용 가능한 프롬프트 객체를 만드는 대신 프로덕션 프롬프트를 애플리케이션 코드에 저장하세요. 프롬프트를 코드로 관리하면 타입이 지정된 입력, 코드 리뷰, 테스트, 기존 배포 절차를 활용해 모델의 동작을 변경할 수 있습니다.

OpenAI API에서 재사용 가능한 프롬프트 객체는 사용 중단 예정(deprecated)입니다. 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

음성 기능 개발

연결

오디오 처리

서비스 출시하기

성능 및 품질

평가

비용 및 처리량

안전 및 거버넌스

인프라 및 접근 권한

운영

핵심 개념

기획

개발

테스트 및 게시

전환 명세

가이드

자료

사용자 식별

ChatGPT 요금제 사용량

가이드

파일 업로드

API

성과 측정

광고주 API

API 레퍼런스

시작하기

시작하기

기초

둘러보기

지원 플랫폼

릴리스

워크플로우

주요 기능

Sites

dot

ChatGPT 스페이스

레퍼런스

맞춤 설정

설정 파일

에이전트 설정

ChatGPT와 Codex 확장하기

Linux

Windows

개발 워크플로우

확장 및 자동화

환경

Codex Cloud

Codex로 개발하기

서드 파티 통합

레퍼런스

권한

Codex Security

사이버 안전

시작하기

기능 설정

ID 및 액세스