Prompt Engineering

Mit der OpenAI API kannst du ein großes Sprachmodell nutzen, um aus einem Prompt Text zu generieren, ähnlich wie mit ChatGPT. Modelle können nahezu jede Art von Textantwort generieren, etwa Code, mathematische Gleichungen, strukturierte JSON-Daten oder Texte, die wie von Menschen geschrieben klingen.

Hier ist ein einfaches Beispiel mit der Responses API.

Text aus einem einfachen Prompt generieren

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."
    }'

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 nicht davon ausgehen, 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. Sie fasst alle Textausgaben des Modells in einer einzigen Zeichenfolge zusammen. So 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.

Hier ist ein einfaches Beispiel mit der Chat Completions API.

Text aus einem einfachen Prompt generieren

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."
            }
        ]
    }'

Die Eigenschaft choices der Antwort enthält ein Array mit den vom Modell generierten Inhalten. In diesem einfachen Beispiel gibt es nur eine Ausgabe, die so aussieht:

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"
  }
]

Neben reinem Text kannst du das Modell auch strukturierte Daten im JSON-Format zurückgeben lassen. Diese Funktion heißt strukturierte Ausgaben.

Ein Modell auswählen

Wenn du Inhalte über die API generierst, ist die Wahl des Modells eine wichtige Entscheidung. Du legst es in den obigen Codebeispielen mit dem Parameter model fest. Hier findest du eine vollständige Liste der verfügbaren Modelle. Bei der Auswahl eines Modells für die Textgenerierung solltest du einige Faktoren berücksichtigen.

Reasoning-Modelle erzeugen eine interne Gedankenkette, um den eingegebenen Prompt zu analysieren. Sie eignen sich besonders gut dafür, komplexe Aufgaben zu verstehen und mehrere Schritte zu planen. In der Regel sind sie allerdings langsamer und teurer in der Nutzung als GPT-Modelle.
GPT-Modelle sind schnell, kosteneffizient und sehr intelligent. Sie profitieren jedoch von genaueren Anweisungen dazu, wie sie Aufgaben erledigen sollen.
Bei großen und kleinen Modellen (mini oder nano) gilt es, zwischen Geschwindigkeit, Kosten und Intelligenz abzuwägen. Große Modelle verstehen Prompts besser und lösen Probleme aus verschiedenen Fachgebieten effektiver. Kleine Modelle sind dagegen in der Regel schneller und günstiger in der Nutzung.

Wenn du dir unsicher bist, ist gpt-6-astra eine gute Standardwahl für die allgemeine Textgenerierung und die schrittweise Verbesserung von Prompts.

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, braucht es sowohl Gespür als auch systematisches Vorgehen, um mit Prompts die gewünschte Ausgabe zu erzielen. Mit geeigneten Techniken und bewährten Methoden kannst du jedoch zuverlässig gute Ergebnisse erreichen.

Manche Techniken des Prompt Engineering funktionieren mit jedem Modell, etwa die Verwendung von Nachrichtenrollen. Unterschiedliche Modelltypen, zum Beispiel Reasoning- und GPT-Modelle, benötigen aber möglicherweise unterschiedlich formulierte Prompts, um die besten Ergebnisse zu erzielen. Selbst verschiedene Snapshots von Modellen derselben Familie können unterschiedliche Ergebnisse liefern. Wenn du komplexere Anwendungen entwickelst, empfehlen wir dir daher dringend:

Lege für deine Anwendungen im Produktivbetrieb bestimmte Modell-Snapshots fest, zum Beispiel gpt-4.1-2025-04-14, um ein konsistentes Verhalten sicherzustellen
Erstelle Tests und Evaluierungssuiten, die das Verhalten von Prompts messen. So kannst du die Leistung überwachen, wenn du Prompts weiterentwickelst oder Modellversionen wechselst und aktualisierst

Sehen wir uns nun einige Tools und Techniken an, mit denen du Prompts erstellen kannst.

Nachrichtenrollen und das Befolgen von Anweisungen

Mit dem API-Parameter instructions oder über 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 übergebenen Anweisungen haben Vorrang vor einem Prompt im Parameter input.

Text mit Anweisungen generieren

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?"
    }'

Das obige Beispiel entspricht ungefähr der Verwendung der folgenden Eingabenachrichten im Array input:

Text mit Nachrichten unterschiedlicher Rollen generieren

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?"
            }
        ]
    }'

Beachte, dass der Parameter instructions nur für die aktuelle Anfrage zur Antwortgenerierung gilt. Wenn du den Parameter previous_response_id verwendest, um den Gesprächszustand zu verwalten, sind die in früheren Gesprächsrunden verwendeten instructions nicht im Kontext enthalten.

Über Nachrichtenrollen kannst du dem Modell Anweisungen (Prompts) mit unterschiedlichen Autoritätsstufen geben.

Text mit Nachrichten unterschiedlicher Rollen generieren

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?"
            }
        ]
    }'

Die OpenAI-Modellspezifikation beschreibt, wie unsere Modelle Nachrichten je nach Rolle unterschiedliche Prioritäten zuweisen.

`developer`	`user`	`assistant`
Nachrichten mit der Rolle `developer` enthalten Anweisungen von den Personen, die die Anwendung entwickeln. Sie haben Vorrang vor Nachrichten mit der Rolle `user`.	Nachrichten mit der Rolle `user` enthalten Anweisungen von den Personen, die die Anwendung nutzen. Sie sind Nachrichten mit der Rolle `developer` nachgeordnet.	Vom Modell generierte Nachrichten haben die Rolle `assistant`.

Ein Gespräch über mehrere Runden kann aus mehreren Nachrichten dieser Typen sowie aus weiteren Inhaltstypen bestehen, die sowohl du als auch das Modell bereitstellen. Hier erfährst du mehr darüber, wie du den Gesprächszustand verwaltest.

Du kannst dir Nachrichten mit den Rollen developer und user wie eine Funktion und ihre Argumente in einer Programmiersprache vorstellen.

Nachrichten mit der Rolle developer legen die Regeln und die Geschäftslogik des Systems fest, ähnlich wie eine Funktionsdefinition.
Nachrichten mit der Rolle user liefern Eingaben und Konfiguration, auf die die Anweisungen aus Nachrichten mit der Rolle developer angewendet werden, ähnlich wie Argumente einer Funktion.

Prompts im Code versionieren

Speichere Prompts für den Produktivbetrieb im Code deiner Anwendung, 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. Ab dem 3. Juni 2026 wird die Erstellung von Prompts weniger in den Vordergrund gestellt. Die Abschaltung von v1/prompts ist für den 30. November 2026 geplant. Den aktuellen Zeitplan findest du auf der Seite zu Abkündigungen. Dort kannst du dich über den aktuellen Stand informieren.

Für neue Arbeiten am Prompt Engineering:

Lege Funktionen zum Erstellen von Prompts in einem kleinen Modul nahe der Funktionalität 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.
Veröffentliche Prompt-Änderungen über dein Deployment-System. Nutze Feature-Flags oder die Konfiguration, wenn du Änderungen schrittweise einführen 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 den Code zu übernehmen.

Nachrichten mit Markdown und XML formatieren

Wenn du developer- und user-Nachrichten schreibst, kannst du mit einer Kombination aus Markdown-Formatierung und XML-Tags dem Modell helfen, die logischen Grenzen zwischen deinem Prompt und den Kontextdaten zu erkennen.

Mit Markdown-Überschriften und -Listen kannst du einzelne Abschnitte eines Prompts kennzeichnen und dem Modell ihre Hierarchie vermitteln. Außerdem können sie deine Prompts während der Entwicklung lesbarer machen. XML-Tags helfen dabei, Anfang und Ende eines Inhalts abzugrenzen, etwa eines Dokuments, das als Referenz dient. Mit XML-Attributen kannst du zudem Metadaten zu Inhalten im Prompt definieren, auf die du in deinen Anweisungen Bezug nehmen kannst.

Eine Developer-Nachricht enthält im Allgemeinen die folgenden Abschnitte, meist in dieser Reihenfolge. Welche Inhalte und welche Reihenfolge am besten funktionieren, kann jedoch vom verwendeten Modell abhängen:

Identität: Beschreibe den Zweck, den Kommunikationsstil und die übergeordneten Ziele des Assistenten.
Anweisungen: Gib dem Modell vor, wie es die gewünschte Antwort generieren soll. Welche Regeln soll es befolgen? Was soll es tun, und was darf es niemals tun? Dieser Abschnitt kann je nach Anwendungsfall mehrere Unterabschnitte enthalten, etwa dazu, wie das Modell benutzerdefinierte Funktionen aufrufen soll.
Beispiele: Gib Beispiele für mögliche Eingaben und die jeweils gewünschte Ausgabe des Modells an.
Kontext: Gib dem Modell alle zusätzlichen Informationen, die es möglicherweise für eine Antwort benötigt, etwa private oder proprietäre Daten, die nicht in seinen Trainingsdaten enthalten sind, oder andere Daten, die du für besonders relevant hältst. Diese Inhalte stehen meist am besten gegen Ende deines Prompts, da du für verschiedene Generierungsanfragen unterschiedlichen Kontext angeben kannst.

Das folgende Beispiel zeigt, wie du mit Markdown und XML-Tags eine developer-Nachricht mit klar getrennten Abschnitten und ergänzenden Beispielen erstellst.

Eine Developer-Nachricht zur Codegenerierung

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>

Einen Prompt zur Codegenerierung über die API senden

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?"
  }'

Kosten und Latenz mit Prompt-Caching reduzieren

Platziere beim Erstellen einer Nachricht Inhalte, die du voraussichtlich immer wieder in deinen API-Anfragen verwendest, möglichst am Anfang deines Prompts und unter den ersten API-Parametern, die du im JSON-Anfragetext an Chat Completions oder Responses übergibst. So kannst du mit Prompt-Caching Kosten und Latenz so weit wie möglich reduzieren.

Few-Shot-Lernen

Mit Few-Shot-Lernen kannst du ein großes Sprachmodell auf eine neue Aufgabe ausrichten, indem du einige Ein- und Ausgabebeispiele in den Prompt aufnimmst, statt das Modell durch Fine-Tuning anzupassen. Das Modell erkennt das Muster in diesen Beispielen implizit und wendet es auf einen Prompt an. Zeige dabei möglichst unterschiedliche Eingaben mit den jeweils gewünschten Ausgaben.

Üblicherweise gibst du Beispiele als Teil einer developer-Nachricht in deiner API-Anfrage an. Hier siehst du eine developer-Nachricht mit Beispielen, die einem Modell zeigen, wie es Bewertungen des Kundenservice als positiv oder negativ klassifizieren soll.

# Identity

You are a helpful assistant that labels short product reviews as
Positive, Negative, or Neutral.

# Instructions

* Only output a single word in your response with no additional formatting
  or commentary.
* Your response should only be one of the words "Positive", "Negative", or
  "Neutral" depending on the sentiment of the product review you are given.

# Examples

<product_review id="example-1">
I absolutely love this headphones — sound quality is amazing!
</product_review>

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

<product_review id="example-2">
Battery life is okay, but the ear pads feel cheap.
</product_review>

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

<product_review id="example-3">
Terrible customer service, I'll never buy from them again.
</product_review>

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

Relevante Kontextinformationen einbeziehen

Es ist oft hilfreich, zusätzliche Kontextinformationen in deinen Prompt aufzunehmen, die das Modell für seine Antwort nutzen kann. Dafür gibt es einige häufige Gründe:

Du möchtest dem Modell Zugriff auf proprietäre Daten oder andere Daten geben, die nicht in seinem Trainingsdatensatz enthalten sind.
Du möchtest die Antwort des Modells auf eine bestimmte Auswahl an Ressourcen beschränken, die du als besonders hilfreich eingestuft hast.

Die Technik, eine Generierungsanfrage an das Modell um relevanten Kontext zu ergänzen, wird auch als Retrieval-Augmented Generation (RAG) bezeichnet. Du kannst deinem Prompt auf verschiedene Weise zusätzlichen Kontext hinzufügen. Beispielsweise kannst du eine Vektordatenbank abfragen und den zurückgegebenen Text in den Prompt aufnehmen oder das integrierte Tool zur Dateisuche von OpenAI verwenden, um Inhalte auf Grundlage hochgeladener Dokumente zu generieren.

Das Kontextfenster bei der Planung berücksichtigen

Modelle können bei einer Generierungsanfrage nur eine begrenzte Datenmenge als Kontext berücksichtigen. Diese Speichergrenze wird als Kontextfenster bezeichnet und in Tokens gemessen. Tokens sind Einheiten der übergebenen Daten, von Text bis hin zu Bildern.

Die Größe des Kontextfensters variiert je nach Modell vom niedrigen Hunderttausenderbereich bis zu einer Million Tokens bei neueren GPT-4.1-Modellen. Die genaue Größe für das jeweilige Modell findest du in der Modelldokumentation.

Prompts für aktuelle Modelle formulieren

GPT-Modelle wie gpt-6-astra profitieren von präzisen Anweisungen, die die zur Erledigung der Aufgabe erforderliche Logik und die benötigten Daten ausdrücklich im Prompt angeben. Beginne mit dem aktuellen Leitfaden zum Formulieren von Prompts, um das neueste Modell optimal zu nutzen.

GPT-6 Astra prompting guide

Erziele mit deinen Prompts für das neueste Modell die besten Ergebnisse: mit aktuellen Empfehlungen, praktischen Beispielen und Hinweisen zur Migration.

Bewährte Methoden zum Formulieren von Prompts für das neueste Modell

Eine vollständige und aktuelle Anleitung findest du unter Bewährte Methoden zum Formulieren von Prompts für das neueste Modell. Die folgenden praktischen Hinweise gelten weiterhin.

GPT-6 Astra

eignet sich sowohl für die Entwicklung neuer Frontends von Grund auf als auch für die Arbeit an großen, etablierten Codebasen. Für optimale Ergebnisse empfehlen wir die folgenden Bibliotheken:

Gestaltung / UI: Tailwind CSS, shadcn/ui, Radix Themes
Symbole: Lucide, Material Symbols, Heroicons
Animation: Motion

Web-Apps von Grund auf entwickeln

GPT-5 kann aus einem einzigen Prompt Frontend-Web-Apps generieren, ohne dass Beispiele nötig sind. Hier ist ein Beispiel-Prompt:

123456You are a world class web developer, capable of producing stunning, interactive, and innovative websites from scratch in a single prompt. You excel at delivering top-tier one-shot solutions.
Your process is simple and follows these steps:
Step 1: Create an evaluation rubric and refine it until you are fully confident.
Step 2: Consider every element that defines a world-class one-shot web app, then use that insight to create a &lt;ONE_SHOT_RUBRIC&gt; with 5–7 categories. Keep this rubric hidden—it's for internal use only.
Step 3: Apply the rubric to iterate on the optimal solution to the given prompt. If it doesn't meet the highest standard across all categories, refine and try again.
Step 4: Aim for simplicity while fully achieving the goal, and avoid external dependencies such as Next.js or React.

Integration in große Codebasen

Bei der Frontend-Entwicklung in größeren Codebasen haben wir festgestellt, dass Prompts mit Anweisungen zu den folgenden Bereichen die besten Ergebnisse liefern:

Grundsätze: Lege Standards für die visuelle Qualität fest, verwende modulare, wiederverwendbare Komponenten und achte auf ein einheitliches Design.
UI/UX: Lege Typografie, Farben, Abstände und Layout, Interaktionszustände (beim Darüberfahren, bei leeren Inhalten, beim Laden) sowie Anforderungen an die Barrierefreiheit fest.
Struktur: Definiere die Datei- und Ordnerstruktur für eine reibungslose Integration.
Komponenten: Gib Beispiele für wiederverwendbare Wrapper und Strategien zur Trennung von Backend-Aufrufen an.
Seiten: Stelle Vorlagen für gängige Layouts bereit.
Anweisungen für den Agenten: Fordere das Modell auf, Designannahmen zu bestätigen, Projektgerüste zu erstellen, Standards durchzusetzen, APIs zu integrieren, Zustände zu testen und Code zu dokumentieren.

Ausführliche Hinweise und Beispiel-Prompts speziell für die Frontend-Entwicklung findest du unter Bewährte Methoden zum Formulieren von Prompts für das neueste Modell.

Konzentriere deine Prompts für agentische und lang andauernde Abläufe mit gpt-6-astra auf drei zentrale Vorgehensweisen: Aufgaben gründlich planen, damit sie vollständig erledigt werden, wichtige Entscheidungen zur Tool-Nutzung vorab klar erläutern und ein TODO-Tool verwenden, um Arbeitsablauf und Fortschritt strukturiert zu verfolgen.

Planung und Ausdauer Weise das Modell an, die Anfrage vollständig zu bearbeiten, bevor es die Kontrolle zurückgibt. Dazu soll es die Anfrage in Teilaufgaben zerlegen und nach jedem Tool-Aufruf prüfen, ob alles erledigt ist.

Remember, you are an agent - please keep going until the user's
query is completely resolved, before ending your turn and yielding
back to the user. Decompose the user's query into all required
sub-requests, and confirm that each is completed. Do not stop
after completing only part of the request. Only terminate your
turn when you are sure that the problem is solved. You must be
prepared to answer multiple queries and only finish the call once
the user has confirmed they're done.

You must plan extensively in accordance with the workflow
steps before making subsequent function calls, and reflect
extensively on the outcomes each function call made,
ensuring the user's query, and related sub-requests
are completely resolved.

Transparenz durch einleitende Erklärungen

Bitte das Modell, zu erklären, warum es ein Tool aufruft, aber nur bei wichtigen Schritten.

Before you call a tool explain why you are calling it

Fortschritt mit Bewertungsrastern und TODOs verfolgen

Verwende ein Tool für TODO-Listen oder ein Bewertungsraster, um eine strukturierte Planung sicherzustellen und keine Schritte auszulassen.

Ausführliche Hinweise und Beispiel-Prompts speziell für die Entwicklung von Agenten findest du in den bewährten Methoden zum Formulieren von Prompts für das neueste Modell.

Prompts für Reasoning-Modelle formulieren

Beim Formulieren von Prompts für ein Reasoning-Modell gibt es einige Unterschiede zu GPT-Modellen zu beachten. In der Regel erzielen Reasoning-Modelle bessere Ergebnisse, wenn sie für eine Aufgabe nur übergeordnete Vorgaben erhalten. GPT-Modelle hingegen profitieren von sehr präzisen Anweisungen.

Den Unterschied zwischen Reasoning- und GPT-Modellen kannst du dir so vorstellen:

Ein Reasoning-Modell ist wie ein erfahrenes Teammitglied. Du kannst ihm ein Ziel vorgeben und darauf vertrauen, dass es die Details selbst ausarbeitet.
Ein GPT-Modell ist wie ein weniger erfahrenes Teammitglied. Es arbeitet am besten mit ausdrücklichen Anweisungen, die auf ein bestimmtes Ergebnis abzielen.

Weitere Informationen zu bewährten Methoden beim Einsatz von Reasoning-Modellen findest du in diesem Leitfaden.

Nächste Schritte

Jetzt kennst du die Grundlagen von Texteingaben und -ausgaben. Als Nächstes könntest du dir eine dieser Ressourcen ansehen.

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

Sieh dir alle Optionen zur Textgenerierung in der API-Referenz an.

Weitere Ressourcen

Weitere Anregungen findest du im OpenAI Cookbook. Es enthält Beispielcode und Links zu Ressourcen von Drittanbietern, darunter:

Vorschläge

Erste Schritte

Grundlegende Konzepte

SDKs und CLI

Ressourcen

Ältere APIs

Modell auswählen

Text und Code

Prompts formulieren

Reasoning-Aufwand

Bilder und Video

Echtzeit und Audio

Spezialisierte Modelle

Agents API

Agents SDK

ChatKit

Suche und Informationsabruf

Tools und Daten anbinden

Arbeitsabläufe mit Tools erstellen

Computer und Code

Medien

GPT-Live

Realtime API

Anwendungen mit Sprachfunktionen entwickeln

Verbindungen

Audioverarbeitung

In Produktion gehen

Leistung und Qualität

Kosten und Durchsatz

Sicherheit und Governance

Infrastruktur und Zugriff

Betrieb

Grundlegende Konzepte

Plan

Build

Test and publish

Conversion specs

Leitfäden

Ressourcen

Erste Schritte

Leitfäden

File Upload

API

Measurement

Advertiser API

API-Referenz

Erste Schritte

Grundlagen

Entdecken

Verfügbar auf

Versionen

Arbeitsabläufe

Funktionen

Referenz

Anpassung

Konfigurationsdatei

Agentenkonfiguration

ChatGPT und Codex erweitern

Linux

Windows

Arbeitsabläufe für die Entwicklung

Erweitern und automatisieren

Umgebungen

Mit Codex entwickeln

Integrationen von Drittanbietern

Referenz

Berechtigungen

Codex Security

Cybersicherheit

Erste Schritte

ChatGPT Work

Identität und Authentifizierung

Workspace-Zugriff, Richtlinien und Modelle

Kontrollen für Plug-ins und Konnektoren

Nutzung, Governance und Compliance

Bereitstellung und Modellanbieter

Community

Blog

Community

Blog