Mit der OpenAI API kannst du ein großes Sprachmodell verwenden, um aus einem Prompt Text zu generieren, ähnlich wie in ChatGPT. Modelle können fast jede Art von Text generieren, etwa Code, mathematische Gleichungen, strukturierte JSON-Daten oder Prosa, die klingt, als hätte ein Mensch sie geschrieben.
Verwende die Responses API, um Anfragen direkt an ein Modell zu stellen, wie in diesem Beispiel zur Textgenerierung.
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."
}'
Die Eigenschaft output der Antwort enthält die vom Modell generierten Inhalte als Array. In diesem einfachen Beispiel enthält das Array nur ein Element:
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": []
}
]
}
]
Das Array output enthält oft mehr als ein Element! Es kann Tool-Aufrufe, Daten zu den von Reasoning-Modellen generierten Reasoning-Tokens und weitere Elemente enthalten. Verlass dich deshalb nicht darauf, die Textausgabe des Modells unter output[0].content[0].text zu finden.
In einigen unserer offiziellen SDKs haben Modellantworten die zusätzliche Eigenschaft output_text. Sie fasst alle Textausgaben des Modells zu einer einzigen Zeichenkette zusammen. So kannst du direkt auf den generierten Text zugreifen.
Neben reinem Text kann das Modell auch strukturierte Daten im JSON-Format zurückgeben. Diese Funktion heißt strukturierte Ausgaben.
Beim Prompt Engineering formulierst du Anweisungen so, dass ein Modell zuverlässig Inhalte generiert, die deinen Anforderungen entsprechen.
Modelle generieren Inhalte nicht deterministisch. Einen Prompt zu formulieren, der das gewünschte Ergebnis liefert, erfordert deshalb sowohl Fingerspitzengefühl als auch systematisches Vorgehen. Mit bewährten Methoden kannst du jedoch zuverlässig gute Ergebnisse erzielen.
Einige Methoden des Prompt Engineering funktionieren bei jedem Modell, etwa der Einsatz von Nachrichtenrollen. Welche Prompts die besten Ergebnisse liefern, hängt jedoch vom Modell ab. Selbst unterschiedliche Snapshots derselben Modellfamilie können unterschiedliche Ergebnisse liefern. Wenn du komplexere Anwendungen entwickelst, empfehlen wir dir ausdrücklich:
- Lege für deine Anwendungen im Produktivbetrieb bestimmte Modell-Snapshots fest (zum Beispiel
gpt-5.5-2026-04-23), damit sich das Modell konsistent verhält.
- Erstelle Tests und Evaluationssuiten, mit denen du misst, wie das Modell auf deine Prompts reagiert. So kannst du die Qualität der Ergebnisse verfolgen, wenn du Prompts überarbeitest, die Modellversion wechselst oder auf eine neuere Version umsteigst.
Die folgenden Werkzeuge und Methoden helfen dir, Prompts zu formulieren.
Bei OpenAI stehen dir viele verschiedene Modelle und mehrere APIs zur Auswahl. Reasoning-Modelle wie gpt-6-astra verhalten sich anders als Chatmodelle. Entsprechend eignen sich für sie andere Prompts. Mit der Responses API erzielen Reasoning-Modelle bessere Ergebnisse und lösen auch anspruchsvollere Aufgaben.
Wenn du eine App zur Textgenerierung entwickelst, empfehlen wir dir die Responses API anstelle der älteren Chat Completions API. Besonders bei einem Reasoning-Modell lohnt sich der Umstieg auf die Responses API.
Du kannst dem Modell Anweisungen mit unterschiedlicher Priorität geben. Dazu verwendest du den API-Parameter instructions und Nachrichtenrollen.
Mit dem Parameter instructions gibst du dem Modell übergeordnete Anweisungen dafür, wie es antworten soll. Du kannst etwa den Ton und die Ziele vorgeben und Beispiele für richtige Antworten nennen. Diese Anweisungen haben Vorrang vor einem Prompt im Parameter input.
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?"
}'
Das Beispiel oben entspricht in etwa einer Anfrage mit den folgenden Nachrichten im Array input:
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?"
}
]
}'
Der Parameter instructions gilt nur für die aktuelle Anfrage. Wenn du den Gesprächsverlauf verwaltest, indem du den Parameter previous_response_id verwendest, enthält der Kontext keine instructions aus früheren Gesprächsrunden.
Die Modellspezifikation von OpenAI beschreibt, wie unsere Modelle Nachrichten je nach Rolle priorisieren.
| developer | user | assistant |
|---|
developer-Nachrichten enthalten Anweisungen von Personen, die die Anwendung
entwickeln. Sie haben Vorrang vor Nachrichten mit der Rolle user.
| user-Nachrichten enthalten Anweisungen von Personen, die die Anwendung
nutzen. Sie haben eine niedrigere Priorität als Nachrichten mit der Rolle developer.
| Nachrichten, die das Modell generiert, haben die Rolle assistant. |
Ein Gespräch über mehrere Runden kann mehrere Nachrichten dieser Typen sowie weitere Arten von Inhalten umfassen, die von dir oder vom Modell stammen. Erfahre mehr darüber, wie du den Gesprächsverlauf verwaltest.
Du kannst dir developer- und user-Nachrichten wie eine Funktion und ihre Argumente in einer Programmiersprache vorstellen.
developer-Nachrichten legen die Regeln und die Geschäftslogik des Systems fest, ähnlich wie eine Funktionsdefinition.
user-Nachrichten liefern ähnlich wie Funktionsargumente die Eingaben und Konfigurationswerte, auf die das Modell die Anweisungen der developer-Nachricht anwendet.
Speichere Prompts für den Produktivbetrieb im Anwendungscode, statt wiederverwendbare Prompt-Objekte anzulegen. Wenn du Prompts im Code verwaltest, kannst du das Modellverhalten mit typisierten Eingaben, Code Reviews, Tests und deinem üblichen Deployment-Prozess ändern.
OpenAI stellt die Unterstützung für wiederverwendbare Prompt-Objekte in der API schrittweise ein.
Ab dem 3. Juni 2026 rückt das Erstellen solcher Prompts in den Hintergrund. Die Abschaltung
von v1/prompts ist für den 30. November 2026 geplant. Den aktuellen Zeitplan findest du
in der Übersicht der Abkündigungen.
Wenn du neue Funktionen zur Textgenerierung entwickelst:
- Bündle den Code zum Erstellen von Prompts in einem kleinen Modul in der Nähe der zugehörigen Funktion.
- Verwende typisierte Funktionsargumente oder Schemas für dynamische Werte wie Kundendaten, Dateien oder Aufgabenoptionen.
- Übergib die generierten Werte für
instructions und input direkt an die Responses API.
- Ergänze repräsentative Testdaten, Tests und Prüfungen zur Ergebnisqualität, bevor du Prompts für den Produktivbetrieb änderst.
- Spiele Prompt-Änderungen über dein Deployment-System aus. Verwende Feature-Flags oder Konfigurationseinstellungen, wenn du Änderungen schrittweise freigeben möchtest.
Wenn deine Integration bereits einen gespeicherten Prompt über eine Prompt-ID oder eine Versionsangabe aufruft, folge der Migrationsanleitung für Prompt-Objekte, um diesen Prompt in deinen Code zu übernehmen.
Jetzt kennst du die Grundlagen der Texteingabe und -ausgabe. Mit diesen Ressourcen kannst du darauf aufbauen.
Einen Prompt im Playground erstellen
Entwickle Prompts im Playground und verfeinere sie Schritt für Schritt.
JSON-Daten mit strukturierten Ausgaben generieren
Stelle sicher, dass die vom Modell generierten JSON-Daten einem JSON-Schema entsprechen.
Vollständige API-Referenz
In der API-Referenz findest du alle Optionen zur Textgenerierung.