Mit der OpenAI API kannst du ein LLM verwenden, um Text aus einem Prompt zu generieren, ähnlich wie mit ChatGPT. Modelle können nahezu jede Art von Textantwort erzeugen, etwa Code, mathematische Gleichungen, strukturierte JSON-Daten oder natürlich klingende Texte.
Verwende die Responses API für direkte Modellanfragen wie diesen Aufruf 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 ein Array mit den vom Modell generierten Inhalten. In diesem einfachen Beispiel gibt es nur eine Ausgabe, die so aussieht:
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-Token und weitere Elemente enthalten. Du kannst dich nicht darauf verlassen, dass die Textausgabe des Modells unter output[0].content[0].text zu finden ist.
Einige unserer offiziellen SDKs stellen in Modellantworten die praktische Eigenschaft output_text bereit, die alle Textausgaben des Modells zu einer einzigen Zeichenfolge zusammenfasst. Damit kannst du einfacher auf die Textausgabe des Modells zugreifen.
Neben reinem Text kannst du das Modell auch strukturierte Daten im JSON-Format zurückgeben lassen. Diese Funktion heißt strukturierte Ausgaben.
Beim Prompt Engineering formulierst du wirksame Anweisungen für ein Modell, damit es zuverlässig Inhalte generiert, die deinen Anforderungen entsprechen.
Da die von einem Modell generierten Inhalte nicht deterministisch sind, ist das Formulieren von Prompts für die gewünschte Ausgabe eine Mischung aus Kunst und Wissenschaft. Mit bestimmten Techniken und bewährten Methoden kannst du jedoch zuverlässig gute Ergebnisse erzielen.
Einige Techniken des Prompt Engineering funktionieren mit jedem Modell, etwa die Verwendung von Nachrichtenrollen. Verschiedene Modelle benötigen aber möglicherweise unterschiedlich formulierte Prompts, um die besten Ergebnisse zu liefern. Selbst verschiedene Snapshots von Modellen derselben Familie können unterschiedliche Ergebnisse erzeugen. Wenn du komplexere Anwendungen entwickelst, empfehlen wir daher dringend:
- Lege für deine Anwendungen im Produktivbetrieb bestimmte Modell-Snapshots fest (zum Beispiel
gpt-5.5-2026-04-23), um ein konsistentes Verhalten sicherzustellen
- Entwickle Tests und Evaluierungssuiten, die das Verhalten deiner Prompts messen. So kannst du die Leistung bei der Weiterentwicklung oder beim Wechsel auf andere oder neuere Modellversionen überwachen
Sehen wir uns nun einige Tools und Techniken an, mit denen du Prompts erstellen kannst.
OpenAI bietet viele verschiedene Modelle und mehrere APIs zur Auswahl. Reasoning-Modelle wie gpt-6-astra verhalten sich anders als Chatmodelle und benötigen andere Prompts, um optimale Ergebnisse zu liefern. Beachte insbesondere, dass Reasoning-Modelle mit der Responses API bessere Leistungen erzielen und eine höhere Intelligenz zeigen.
Für jede App zur Textgenerierung empfehlen wir die Responses API anstelle der älteren Chat Completions API. Wenn du ein Reasoning-Modell verwendest, lohnt sich der Umstieg auf Responses besonders.
Mit dem API-Parameter instructions und Nachrichtenrollen kannst du dem Modell Anweisungen mit unterschiedlichen Autoritätsstufen geben.
Der Parameter instructions gibt dem Modell übergeordnete Anweisungen dazu, wie es sich beim Generieren einer Antwort verhalten soll. Dazu gehören Tonfall, Ziele und Beispiele für korrekte Antworten. Alle auf diese Weise bereitgestellten 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 obige Beispiel entspricht in etwa der Verwendung der folgenden Eingabenachrichten 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?"
}
]
}'
Beachte, dass der Parameter instructions nur für die aktuelle Anfrage zur Antwortgenerierung gilt. Wenn du den Parameter previous_response_id zum Verwalten des Gesprächszustands verwendest, sind die in früheren Gesprächsrunden verwendeten instructions nicht im Kontext enthalten.
Die OpenAI-Modellspezifikation beschreibt, wie unsere Modelle Nachrichten mit unterschiedlichen Rollen unterschiedlich priorisieren.
| developer |
user |
assistant |
|---|
developer-Nachrichten enthalten Anweisungen von den Personen, die die Anwendung entwickeln.
Sie haben Vorrang vor user-Nachrichten.
| user-Nachrichten enthalten Anweisungen von Endnutzenden.
Sie sind developer-Nachrichten nachgeordnet.
| Vom Modell generierte Nachrichten haben die Rolle assistant. |
Ein Gespräch über mehrere Runden kann aus mehreren Nachrichten dieser Typen sowie weiteren Inhaltstypen bestehen, die sowohl du als auch das Modell bereitstellen. Hier erfährst du mehr über das Verwalten des Gesprächszustands.
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 Eingaben und Konfigurationen, auf die die Anweisungen der developer-Nachricht angewendet werden, ähnlich wie Argumente einer Funktion.
Speichere Prompts für den Produktivbetrieb in deinem Anwendungscode, statt wiederverwendbare Prompt-Objekte zu erstellen. Wenn du Prompts im Code verwaltest, kannst du typisierte Eingaben, Code Reviews, Tests und deinen üblichen Deployment-Prozess nutzen, um das Modellverhalten zu ändern.
OpenAI kündigt wiederverwendbare Prompt-Objekte in der API ab. Das Erstellen von Prompts wird
ab dem 3. Juni 2026 weniger in den Vordergrund gestellt. Die Abschaltung von v1/prompts ist
für den 30. November 2026 geplant. Auf der Seite zu
Abkündigungen findest du den aktuellen
Zeitplan.
Für neue Vorhaben zur Textgenerierung:
- Lege Funktionen zum Erstellen von Prompts in einem kleinen Modul nahe der Funktion ab, die sie unterstützen.
- 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 Test-Fixtures, Tests und Evaluierungsprüfungen, bevor du Prompts für den Produktivbetrieb änderst.
- Stelle Prompt-Änderungen über dein Deployment-System bereit. Nutze Feature-Flags oder Konfigurationen, wenn du Änderungen schrittweise veröffentlichen möchtest.
Wenn deine Integration bereits einen gespeicherten Prompt über eine Prompt-ID oder Version aufruft, nutze den Migrationsleitfaden für Prompt-Objekte, um diesen Prompt in deinen Code zu übernehmen.
Jetzt kennst du die Grundlagen von Texteingaben und -ausgaben. Als Nächstes könnte eine dieser Ressourcen für dich interessant sein.
Einen Prompt im Playground erstellen
Nutze den Playground, um Prompts zu entwickeln und schrittweise zu verbessern.
JSON-Daten mit strukturierten Ausgaben generieren
Stelle sicher, dass die von einem Modell ausgegebenen JSON-Daten einem JSON-Schema entsprechen.
Vollständige API-Referenz
Entdecke alle Optionen zur Textgenerierung in der API-Referenz.
