장시간 대화를 이어갈 때는 컨텍스트 압축을 사용해 이후 턴에 필요한 상태를 유지하면서 컨텍스트 크기를 줄일 수 있습니다.
대화가 길어질수록 컨텍스트 압축은 품질, 비용, 지연 시간 사이의 균형을 맞추는 데 도움이 됩니다. 대화 기록을 변경할 때 추론을 보존하는 방법은 접두부를 그대로 유지하기를 참고하세요.
Responses API의 응답 생성 요청(POST /responses 또는 client.responses.create)에서 context_management에 compact_threshold를 설정하면 서버 측 컨텍스트 압축을 활성화할 수 있습니다.
- 렌더링된 컨텍스트의 토큰 수가 설정한 임계값을 넘으면 서버가 컨텍스트 압축을 실행합니다.
- 이 모드에서는
/responses/compact를 별도로 호출할 필요가 없습니다.
- 응답 스트림에는 암호화된 컨텍스트 압축 항목이 포함됩니다.
- Responses API의 응답 생성 요청에
store=false를 설정하면 데이터 비보관(ZDR) 환경에서도 서버 측 컨텍스트 압축을 사용할 수 있습니다.
반환된 컨텍스트 압축 항목은 이전 상태와 추론의 핵심 내용을 더 적은 토큰으로 다음 실행에 전달합니다. 이 항목은 내부 내용이 드러나지 않는 형식이며 사람이 직접 해석하는 용도로 설계되지 않았습니다.
입력 배열로 요청을 연결하는 무상태 방식에서는 평소처럼 배열에 출력 항목을 추가하세요. previous_response_id를 사용한다면 매 턴 새 사용자 메시지만 전달하세요. 두 방식 모두 컨텍스트 압축 항목을 통해 다음 컨텍스트 윈도우에 필요한 정보가 전달됩니다.
기존 입력 항목 뒤에 출력 항목을 추가한 다음, 가장 최근의 컨텍스트 압축 항목보다 앞에 있는 항목을 제거할 수 있습니다. 이렇게 하면 요청 크기가 작아지고 응답이 특히 오래 걸리는 경우의 지연 시간도 줄어듭니다. 가장 최근의 컨텍스트 압축 항목에는 대화를 이어가는 데 필요한 컨텍스트가 담겨 있습니다. previous_response_id로 요청을 연결하는 경우에는 항목을 직접 제거하지 마세요.
- 평소처럼
/responses를 호출하되, context_management에 compact_threshold를 지정해 서버 측 컨텍스트 압축을 활성화하세요.
- 응답을 스트리밍하는 도중 컨텍스트 크기가 임계값을 넘으면 서버가 컨텍스트 압축을 실행합니다. 서버는 같은 스트림으로 컨텍스트 압축 항목을 출력하고 컨텍스트에서 불필요한 항목을 제거한 뒤 추론을 이어갑니다.
- 다음 두 방식 중 하나로 호출을 이어가세요. 입력 배열로 요청을 연결하는 무상태 방식에서는 컨텍스트 압축 항목을 포함한 출력을 다음 입력 배열에 추가하세요.
previous_response_id로 요청을 연결하는 방식에서는 매 턴 새 사용자 메시지만 보내고 이전 응답의 ID를 함께 전달하세요.
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
40import OpenAI from "openai";
import { toResponseInputItems } from "openai/lib/responses/ResponseInputItems";
import { createInterface } from "node:readline";
const client = new OpenAI();
const conversation = [
{
type: "message",
role: "user",
content: "Let's begin a long coding task.",
},
];
// Subscribe before generation so piped follow-up turns are not lost.
const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
const turns = lines[Symbol.asyncIterator]();
async function respond() {
const response = await client.responses.create({
model: "gpt-5.3-codex",
input: conversation,
store: false,
context_management: [{ type: "compaction", compact_threshold: 200_000 }],
});
conversation.push(...toResponseInputItems(response.output));
console.log(response.output_text);
}
try {
await respond();
for await (const line of turns) {
if (!line.trim()) continue;
conversation.push({ type: "message", role: "user", content: line });
await respond();
}
} finally {
lines.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
29conversation = [
{
"type": "message",
"role": "user",
"content": "Let's begin a long coding task.",
}
]
while keep_going:
response = client.responses.create(
model="gpt-5.3-codex",
input=conversation,
store=False,
context_management=[{"type": "compaction", "compact_threshold": 200000}],
)
conversation.extend(response.output)
try:
next_input = get_next_user_input()
except EOFError:
break
conversation.append(
{
"type": "message",
"role": "user",
"content": next_input,
}
)
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 (
"bufio"
"context"
"encoding/json"
"fmt"
"os"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
conversation := []responses.ResponseInputItemUnionParam{
responses.ResponseInputItemParamOfMessage("Let's begin a long coding task.", responses.EasyInputMessageRoleUser),
}
scanner := bufio.NewScanner(os.Stdin)
for {
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-5.3-codex",
Store: openai.Bool(false),
Input: responses.ResponseNewParamsInputUnion{OfInputItemList: conversation},
ContextManagement: []responses.ResponseNewParamsContextManagement{{
Type: "compaction", CompactThreshold: openai.Int(200000),
}},
})
if err != nil {
panic(err)
}
conversation = append(conversation, outputAsInput(response.Output)...)
fmt.Println(response.OutputText())
if !scanner.Scan() {
break
}
conversation = append(conversation,
responses.ResponseInputItemParamOfMessage(scanner.Text(), responses.EasyInputMessageRoleUser),
)
}
if err := scanner.Err(); err != nil {
panic(err)
}
}
func outputAsInput(output []responses.ResponseOutputItemUnion) []responses.ResponseInputItemUnionParam {
input := make([]responses.ResponseInputItemUnionParam, 0, len(output))
for _, item := range output {
var converted responses.ResponseInputItemUnion
if err := json.Unmarshal([]byte(item.RawJSON()), &converted); err != nil {
panic(err)
}
input = append(input, converted.ToParam())
}
return input
}
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
48import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
var conversation = new ArrayList<ResponseInputItem>();
conversation.add(
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.USER)
.content("Let's begin a long coding task.")
.build()));
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-5.3-codex")
.inputOfResponse(conversation)
.store(false)
.putAdditionalBodyProperty(
"context_management",
JsonValue.from(List.of(Map.of("type", "compaction", "compact_threshold", 200000))))
.build();
var response = client.responses().create(params);
response.output().stream()
.map(item -> JsonValue.from(item).convert(ResponseInputItem.class))
.forEach(conversation::add);
conversation.add(
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.USER)
.content("Now implement the next step.")
.build()));
client
.responses()
.create(params.toBuilder().inputOfResponse(conversation).build())
.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
24
25
26
27
28
29
30
31
32
33
34require "openai"
client = OpenAI::Client.new
conversation = [
{
type: :message,
role: :user,
content: "Let's begin a long coding task."
}
]
loop do
response = client.responses.create(
model: "gpt-5.3-codex",
input: conversation,
store: false,
context_management: [
{
type: :compaction,
compact_threshold: 200_000
}
]
)
conversation.concat(response.output)
puts(response.output_text)
line = $stdin.gets
break unless line
conversation << {
type: :message,
role: :user,
content: line.chomp
}
end
장시간 실행되는 워크플로우에서 무상태 컨텍스트 압축을 직접 제어하려면 독립형 컨텍스트 압축 엔드포인트를 사용하세요.
이 엔드포인트는 완전한 무상태 방식으로 작동하며 ZDR 환경에서도 사용할 수 있습니다.
메시지, 도구, 기타 항목을 포함한 전체 컨텍스트 윈도우를 보내면 엔드포인트가 압축된 새 컨텍스트 윈도우를 반환합니다. 이 윈도우를 다음 /responses 호출에 전달할 수 있습니다.
반환된 컨텍스트 윈도우에는 암호화된 컨텍스트 압축 항목이 포함됩니다. 이 항목은 이전 상태와 추론의 핵심 내용을 더 적은 토큰으로 전달합니다. 내부 내용이 드러나지 않는 형식이며 사람이 직접 해석하는 용도로 설계되지 않았습니다.
압축된 컨텍스트 윈도우에는 일반적으로 컨텍스트 압축 항목 외에 다른 항목도 들어 있습니다. 이전 윈도우의 항목이 그대로 포함될 수도 있습니다.
/responses/compact의 출력에서 항목을 제거하지 마세요. 반환된 윈도우 전체가 다음 호출에 사용할 컨텍스트 윈도우이므로 다음 /responses 호출에 그대로 전달하세요.
- 평소처럼
/responses를 호출하면서 사용자 메시지, 어시스턴트 출력, 도구와의 상호작용을 포함한 입력 항목을 보내세요.
- 컨텍스트 윈도우가 커지면
/responses/compact를 호출해 압축된 새 컨텍스트 윈도우를 생성하세요. 이때도 /responses/compact에 보내는 윈도우의 크기는 모델의 컨텍스트 윈도우 한도를 넘지 않아야 합니다.
- 이후
/responses를 호출할 때는 전체 대화 기록 대신 반환된 컨텍스트 윈도우를 컨텍스트 압축 항목까지 포함해 입력으로 전달하세요.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import OpenAI from "openai";
const client = new OpenAI();
const conversation = [{ role: "user", content: "Plan a trip to Kyoto." }];
const compacted = await client.responses.compact({
model: "gpt-6-astra",
input: conversation,
});
const nextInput = [
...compacted.output.map((item) => item),
{ role: "user", content: "Add two more days to the itinerary." },
];
const response = await client.responses.create({
model: "gpt-6-astra",
input: nextInput,
store: false,
});
console.log(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# Full window collected from prior turns
long_input_items_array = [{"role": "user", "content": "Plan a trip to Kyoto."}]
# 1) Compact the current window
compacted = client.responses.compact(
model="gpt-6-astra",
input=long_input_items_array,
)
# 2) Start the next turn by appending a new user message
next_input = [
*compacted.output, # Use compact output as-is
{
"type": "message",
"role": "user",
"content": user_input_message(),
},
]
next_response = client.responses.create(
model="gpt-6-astra",
input=next_input,
store=False, # Keep the flow ZDR-friendly
)
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
54package main
import (
"bufio"
"context"
"encoding/json"
"fmt"
"os"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
longInputItems := []responses.ResponseInputItemUnionParam{
responses.ResponseInputItemParamOfMessage("Plan a trip to Kyoto.", responses.EasyInputMessageRoleUser),
}
compacted, err := client.Responses.Compact(context.Background(), responses.ResponseCompactParams{
Model: "gpt-6-astra",
Input: responses.ResponseCompactParamsInputUnion{OfResponseInputItemArray: longInputItems},
})
if err != nil {
panic(err)
}
scanner := bufio.NewScanner(os.Stdin)
if !scanner.Scan() {
return
}
nextInput := append(outputAsInput(compacted.Output),
responses.ResponseInputItemParamOfMessage(scanner.Text(), responses.EasyInputMessageRoleUser),
)
nextResponse, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Store: openai.Bool(false),
Input: responses.ResponseNewParamsInputUnion{OfInputItemList: nextInput},
})
if err != nil {
panic(err)
}
fmt.Println(nextResponse.OutputText())
}
func outputAsInput(output []responses.ResponseOutputItemUnion) []responses.ResponseInputItemUnionParam {
input := make([]responses.ResponseInputItemUnionParam, 0, len(output))
for _, item := range output {
var converted responses.ResponseInputItemUnion
if err := json.Unmarshal([]byte(item.RawJSON()), &converted); err != nil {
panic(err)
}
input = append(input, converted.ToParam())
}
return input
}
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
52import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseCompactParams;
import com.openai.models.responses.ResponseCompactionItemParam;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.ArrayList;
var compacted =
client
.responses()
.compact(
ResponseCompactParams.builder()
.model("gpt-6-astra")
.input("Plan a trip to Kyoto.")
.build());
var input = new ArrayList<ResponseInputItem>();
for (var item : compacted.output()) {
item.message().map(ResponseInputItem::ofResponseOutputMessage).ifPresent(input::add);
item.reasoning().map(ResponseInputItem::ofReasoning).ifPresent(input::add);
item.compaction()
.map(
value ->
ResponseInputItem.ofCompaction(
ResponseCompactionItemParam.builder()
.id(value.id())
.encryptedContent(value.encryptedContent())
.build()))
.ifPresent(input::add);
}
input.add(
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.USER)
.content("Add restaurant recommendations.")
.build()));
client
.responses()
.create(
ResponseCreateParams.builder()
.model("gpt-6-astra")
.inputOfResponse(input)
.store(false)
.build())
.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
24
25
26
27require "openai"
client = OpenAI::Client.new
long_input = [
{
role: :user,
content: "Plan a trip to Kyoto."
}
]
compaction = client.responses.compact(
model: "gpt-6-astra",
input: long_input
)
next_input = [
*compaction.output,
{
type: :message,
role: :user,
content: "Add restaurant recommendations."
}
]
response = client.responses.create(
model: "gpt-6-astra",
input: next_input,
store: false
)
puts(response.output_text)
