Ingénierie de prompts

Avec l’API OpenAI, vous pouvez utiliser un grand modèle de langage pour générer du texte à partir d’un prompt, comme vous le feriez avec ChatGPT. Les modèles peuvent générer presque tous les types de réponses textuelles : du code, des équations mathématiques, des données JSON structurées ou encore des textes semblables à ceux qu’un humain écrirait.

Voici un exemple simple utilisant l’API Responses.

Générez du texte à partir d’un prompt simple

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

La propriété output de la réponse contient un tableau des contenus générés par le modèle. Dans cet exemple simple, il ne contient qu’un seul élément, qui se présente ainsi :

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

Le tableau output contient souvent plusieurs éléments ! Il peut contenir des appels d’outils, des données sur les tokens de raisonnement générés par les modèles de raisonnement et d’autres éléments. Ne supposez pas que le texte généré par le modèle se trouve à l’emplacement output[0].content[0].text.

Certains de nos SDK officiels proposent une propriété output_text dans les réponses du modèle pour en faciliter l’utilisation. Elle regroupe toutes les sorties textuelles du modèle dans une seule chaîne de caractères et peut ainsi offrir un moyen plus direct d’accéder au texte généré.

En plus du texte brut, vous pouvez demander au modèle de renvoyer des données structurées au format JSON grâce à la fonctionnalité Sorties structurées.

Voici un exemple simple utilisant l’API Chat Completions.

Générez du texte à partir d’un prompt simple

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

La propriété choices de la réponse contient un tableau des contenus générés par le modèle. Dans cet exemple simple, il ne contient qu’un seul élément, qui se présente ainsi :

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

En plus du texte brut, vous pouvez demander au modèle de renvoyer des données structurées au format JSON grâce à la fonctionnalité Sorties structurées.

Choisir un modèle

Lorsque vous générez du contenu avec l’API, le choix du modèle est essentiel : il correspond au paramètre model dans les exemples de code ci-dessus. Vous trouverez ici la liste complète des modèles disponibles. Voici quelques facteurs à prendre en compte pour choisir un modèle de génération de texte.

Les modèles de raisonnement génèrent un raisonnement détaillé interne (« chain-of-thought ») pour analyser le prompt d’entrée et excellent dans la compréhension des tâches complexes et la planification en plusieurs étapes. Ils sont aussi généralement plus lents et plus coûteux à utiliser que les modèles GPT.
Les modèles GPT sont rapides, économiques et très intelligents, mais donnent de meilleurs résultats avec des instructions plus explicites sur la manière d’accomplir les tâches.
Les grands et petits modèles (mini ou nano) offrent différents compromis entre vitesse, coût et intelligence. Les grands modèles comprennent mieux les prompts et résolvent plus efficacement les problèmes dans divers domaines, tandis que les petits modèles sont généralement plus rapides et moins coûteux à utiliser.

En cas de doute, gpt-6-astra constitue un bon choix par défaut pour la génération de texte à usage général et l’amélioration itérative des prompts.

Ingénierie de prompts

L’ingénierie de prompts consiste à rédiger des instructions efficaces pour qu’un modèle génère de façon régulière du contenu répondant à vos exigences.

Le contenu généré par un modèle n’étant pas déterministe, la rédaction de prompts permettant d’obtenir le résultat souhaité tient à la fois de l’art et de la science. Vous pouvez néanmoins appliquer des techniques et des bonnes pratiques pour obtenir régulièrement de bons résultats.

Certaines techniques d’ingénierie de prompts, comme l’utilisation des rôles de message, fonctionnent avec tous les modèles. Toutefois, différents types de modèles, par exemple les modèles de raisonnement et les modèles GPT, peuvent nécessiter des prompts différents pour donner les meilleurs résultats. Même des versions figées de modèles d’une même famille peuvent produire des résultats différents. À mesure que vous développez des applications plus complexes, nous vous recommandons donc vivement de suivre ces pratiques :

Associez vos applications de production à des versions figées précises des modèles (par exemple gpt-4.1-2025-04-14) pour garantir un comportement cohérent
Créez des tests et des suites d’évaluation qui mesurent le comportement des prompts afin de suivre les performances au fil des itérations ou lorsque vous changez de version de modèle ou passez à une version plus récente

Examinons maintenant quelques outils et techniques à votre disposition pour construire des prompts.

Rôles des messages et respect des instructions

Vous pouvez fournir au modèle des instructions avec différents niveaux d’autorité à l’aide du paramètre d’API instructions ou des rôles de message.

Le paramètre instructions fournit au modèle des instructions générales sur le comportement à adopter pour générer une réponse, notamment le ton, les objectifs et des exemples de réponses correctes. Toute instruction fournie de cette manière est prioritaire sur un prompt transmis dans le paramètre input.

Générez du texte avec des instructions

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

L’exemple ci-dessus revient à peu près à utiliser les messages d’entrée suivants dans le tableau input :

Générez du texte avec des messages de rôles différents

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

Notez que le paramètre instructions ne s’applique qu’à la requête de génération de réponse en cours. Si vous gérez l’état de la conversation avec le paramètre previous_response_id, les instructions instructions utilisées lors des tours précédents ne seront pas présentes dans le contexte.

Vous pouvez fournir au modèle des instructions (prompts) avec différents niveaux d’autorité à l’aide des rôles de message.

Générez du texte avec des messages de rôles différents

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

La spécification du modèle d’OpenAI décrit comment nos modèles attribuent différents niveaux de priorité aux messages selon leur rôle.

`developer`	`user`	`assistant`
Les messages `developer` sont des instructions fournies par le développeur de l’application. Ils sont prioritaires sur les messages `user`.	Les messages `user` sont des instructions fournies par un utilisateur final. Leur priorité est inférieure à celle des messages `developer`.	Les messages générés par le modèle ont le rôle `assistant`.

Une conversation en plusieurs tours peut comprendre plusieurs messages de ces types, ainsi que d’autres types de contenu fournis par vous et par le modèle. Pour en savoir plus, consultez la documentation sur la gestion de l’état de la conversation.

Vous pouvez comparer les messages developer et user à une fonction et à ses arguments dans un langage de programmation.

Les messages developer fournissent les règles et la logique métier du système, comme une définition de fonction.
Les messages user fournissent les données d’entrée et la configuration auxquelles s’appliquent les instructions du message developer, comme les arguments d’une fonction.

Versionnez les prompts dans le code

Stockez les prompts de production dans le code de votre application au lieu de créer des objets prompt réutilisables. En gérant les prompts dans le code, vous pouvez utiliser des entrées typées, la revue de code, des tests et votre processus de déploiement habituel pour modifier le comportement du modèle.

OpenAI rend obsolètes les objets prompt réutilisables dans l’API. La création de prompts sera moins mise en avant à partir du 3 juin 2026, et l’arrêt de v1/prompts est prévu pour le 30 novembre 2026. Consultez la page des dépréciations pour connaître le calendrier à jour.

Pour tout nouveau travail d’ingénierie de prompts :

Regroupez les fonctions de construction des prompts dans un petit module à proximité de la fonctionnalité qu’elles prennent en charge.
Utilisez des arguments de fonction typés ou des schémas pour les valeurs dynamiques, telles que les données client, les fichiers ou les options des tâches.
Transmettez les valeurs générées pour instructions et input directement à l’API Responses.
Ajoutez des jeux de données de test représentatifs, des tests et des contrôles d’évaluation avant de modifier les prompts de production.
Déployez les modifications des prompts via votre système de déploiement. Utilisez des indicateurs de fonctionnalité ou la configuration si vous avez besoin d’un déploiement progressif.

Si votre intégration appelle déjà un prompt enregistré à l’aide d’un identifiant ou d’une version de prompt, suivez le guide de migration des objets prompt pour transférer ce prompt dans le code.

Mise en forme des messages avec Markdown et XML

Lorsque vous rédigez des messages developer et user, vous pouvez aider le modèle à comprendre les délimitations logiques de votre prompt et des données de contexte en combinant la mise en forme Markdown et les balises XML.

Les titres et les listes Markdown permettent de distinguer les sections d’un prompt et d’indiquer leur hiérarchie au modèle. Ils peuvent aussi rendre vos prompts plus lisibles pendant le développement. Les balises XML permettent de délimiter le début et la fin d’un contenu, comme un document complémentaire utilisé comme référence. Les attributs XML peuvent également servir à définir des métadonnées sur le contenu du prompt, auxquelles vos instructions peuvent faire référence.

En général, un message developer contient les sections suivantes, habituellement dans cet ordre (le contenu et l’ordre optimaux peuvent toutefois varier selon le modèle utilisé) :

Identité : Décrivez la fonction, le style de communication et les objectifs généraux de l’assistant.
Instructions : Indiquez au modèle comment générer la réponse souhaitée. Quelles règles doit-il suivre ? Que doit-il faire et que ne doit-il jamais faire ? Cette section peut comporter plusieurs sous-sections adaptées à votre cas d’usage, par exemple pour expliquer comment le modèle doit appeler des fonctions personnalisées.
Exemples : Fournissez des exemples d’entrées possibles, accompagnés de la sortie attendue du modèle.
Contexte : Fournissez au modèle toute information supplémentaire dont il pourrait avoir besoin pour générer une réponse, comme des données privées ou propriétaires absentes de ses données d’entraînement, ou toute autre donnée que vous savez particulièrement pertinente. Il est généralement préférable de placer ce contenu vers la fin du prompt, car le contexte peut varier d’une requête de génération à l’autre.

Voici un exemple d’utilisation de Markdown et de balises XML pour construire un message developer avec des sections distinctes et des exemples à l’appui.

Un message developer pour la génération de code

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>

Envoyez un prompt pour générer du code via l’API

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

Réduisez les coûts et la latence grâce à la mise en cache des prompts

Lorsque vous construisez un message, essayez de placer le contenu que vous prévoyez de réutiliser dans vos requêtes API au début du prompt, et parmi les premiers paramètres API que vous transmettez dans le corps JSON de la requête à Chat Completions ou Responses. Vous maximisez ainsi les économies et les gains de latence liés à la mise en cache des prompts.

Apprentissage few-shot

L’apprentissage few-shot permet d’orienter un grand modèle de langage vers une nouvelle tâche en incluant quelques exemples d’entrées et de sorties dans le prompt, plutôt qu’en procédant à l’affinage du modèle. Le modèle déduit implicitement le schéma de ces exemples et l’applique à un prompt. Lorsque vous fournissez des exemples, essayez de présenter des entrées possibles variées, accompagnées des sorties souhaitées.

En général, vous fournissez les exemples dans un message developer de votre requête API. Voici un message developer contenant des exemples qui montrent au modèle comment classer des avis sur le service client comme positifs ou négatifs.

# 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>

Incluez des informations de contexte pertinentes

Il est souvent utile d’inclure dans votre prompt des informations de contexte supplémentaires que le modèle peut utiliser pour générer une réponse. Voici quelques raisons courantes de le faire :

Pour donner au modèle accès à des données propriétaires ou à toute autre donnée absente du jeu de données utilisé pour son entraînement.
Pour limiter les sources sur lesquelles le modèle fonde sa réponse à un ensemble précis de ressources que vous jugez les plus utiles.

La technique qui consiste à ajouter du contexte pertinent à la requête de génération du modèle est parfois appelée génération augmentée par récupération (RAG). Vous pouvez enrichir le contexte du prompt de différentes façons, par exemple en interrogeant une base de données vectorielle et en y intégrant le texte obtenu, ou en utilisant l’outil de recherche de fichiers intégré d’OpenAI pour générer du contenu à partir de documents importés.

Tenez compte de la fenêtre de contexte

Les modèles ne peuvent traiter qu’une quantité limitée de données dans le contexte pris en compte lors d’une requête de génération. Cette limite de mémoire est appelée fenêtre de contexte et s’exprime en tokens, des fragments des données que vous transmettez, qu’il s’agisse de texte ou d’images.

La taille de la fenêtre de contexte varie selon les modèles, d’un peu plus de 100 000 tokens jusqu’à un million pour les modèles GPT-4.1 plus récents. Consultez la documentation des modèles pour connaître la taille exacte de la fenêtre de contexte de chacun.

Conception de prompts pour les modèles actuels

Les modèles GPT comme gpt-6-astra donnent de meilleurs résultats lorsque le prompt contient des instructions précises qui indiquent explicitement la logique et les données nécessaires pour accomplir la tâche. Pour tirer le meilleur parti du dernier modèle, commencez par le guide actuel de conception de prompts.

GPT-6 Astra prompting guide

Tirez le meilleur parti des prompts pour le dernier modèle grâce à des recommandations à jour, des exemples pratiques et des notes de migration.

Bonnes pratiques de conception de prompts pour le dernier modèle

Pour des recommandations complètes et à jour, consultez les bonnes pratiques de conception de prompts pour le dernier modèle. Les rappels pratiques ci-dessous restent valables.

GPT-6 Astra

obtient de bons résultats aussi bien pour créer des interfaces front-end à partir de zéro que pour contribuer à des bases de code volumineuses et bien établies. Pour obtenir les meilleurs résultats, nous recommandons les bibliothèques suivantes :

Styles / UI : Tailwind CSS, shadcn/ui, Radix Themes
Icônes : Lucide, Material Symbols, Heroicons
Animation : Motion

Création d’applications web à partir de zéro

GPT-5 peut générer des applications web front-end à partir d’un seul prompt, sans aucun exemple. Voici un exemple de 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.

Intégration dans de grandes bases de code

Pour les travaux d’ingénierie front-end dans de grandes bases de code, nous avons constaté que l’ajout des catégories d’instructions suivantes à vos prompts donne les meilleurs résultats :

Principes : Fixez des critères de qualité visuelle, utilisez des composants modulaires et réutilisables, et veillez à la cohérence du design.
UI/UX : Précisez la typographie, les couleurs, les espacements et la mise en page, les états d’interaction (survol, absence de contenu, chargement) et les exigences d’accessibilité.
Structure : Définissez l’organisation des fichiers et des dossiers pour faciliter l’intégration.
Composants : Fournissez des exemples de wrappers réutilisables et des stratégies pour isoler les appels au backend.
Pages : Fournissez des modèles pour les mises en page courantes.
Instructions pour l’agent : Demandez au modèle de confirmer les hypothèses de conception, de créer la structure initiale des projets, de faire respecter les normes, d’intégrer les API, de tester les états et de documenter le code.

Pour des recommandations détaillées et des exemples de prompts propres au développement front-end, consultez les bonnes pratiques de conception de prompts pour le dernier modèle.

Pour les exécutions agentiques et de longue durée avec gpt-6-astra, concentrez vos prompts sur trois pratiques essentielles : planifiez soigneusement les tâches pour les mener à bien dans leur intégralité, fournissez des préambules clairs pour les décisions importantes d’utilisation des outils et utilisez un outil TODO pour suivre le workflow et l’avancement de manière organisée.

Planification et persévérance Demandez au modèle de traiter l’intégralité de la demande avant de rendre la main, en la décomposant en sous-tâches et en faisant le point après chaque appel d’outil pour vérifier que rien n’a été oublié.

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.

Des préambules pour plus de transparence

Demandez au modèle d’expliquer pourquoi il appelle un outil, mais uniquement aux étapes importantes.

Before you call a tool explain why you are calling it

Suivi de la progression à l’aide de grilles d’évaluation et de listes de tâches

Utilisez un outil de liste de tâches ou une grille d’évaluation pour imposer une planification structurée et éviter d’oublier des étapes.

Pour obtenir des conseils détaillés et des exemples de prompts propres à la création d’agents, consultez les bonnes pratiques de conception de prompts pour le dernier modèle.

Conception de prompts pour les modèles de raisonnement

La conception de prompts pour un modèle de raisonnement diffère sur certains points de celle destinée à un modèle GPT. En général, les modèles de raisonnement donnent de meilleurs résultats lorsque les tâches sont accompagnées uniquement de consignes générales. À l’inverse, les modèles GPT bénéficient d’instructions très précises.

Voici une façon de comprendre la différence entre les modèles de raisonnement et les modèles GPT.

Un modèle de raisonnement est comparable à un collègue expérimenté. Vous pouvez lui donner un objectif à atteindre et lui faire confiance pour régler les détails.
Un modèle GPT est comparable à un collègue débutant. Il sera plus efficace si vous lui donnez des instructions explicites pour produire un résultat précis.

Pour en savoir plus sur les bonnes pratiques d’utilisation des modèles de raisonnement, consultez ce guide.

Prochaines étapes

Maintenant que vous connaissez les bases des entrées et sorties textuelles, vous pouvez poursuivre avec l’une de ces ressources.

Créez un prompt dans le Playground

Utilisez le Playground pour élaborer des prompts et les améliorer au fil des itérations.

Générez des données JSON avec les sorties structurées

Assurez-vous que les données JSON produites par un modèle respectent un schéma JSON.

Référence complète de l’API

Consultez toutes les options de génération de texte dans la référence de l’API.

Autres ressources

Pour trouver d’autres idées, consultez l’OpenAI Cookbook, qui contient des exemples de code ainsi que des liens vers des ressources tierces, notamment :

Suggestions

Bien démarrer

Concepts fondamentaux

SDK et CLI

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Conception de prompts

Raisonnement

Images et vidéo

Realtime et audio

Modèles spécialisés

API Agents

SDK Agents

ChatKit

Recherche et récupération

Connectez des outils et des données

Créez des flux de travail avec des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Développez avec la voix

Connexions

Traitement audio

Passez en production

Performances et qualité

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts fondamentaux

Plan

Build

Test and publish

Conversion specs

Guides

Ressources

Bien démarrer

Guides

File Upload

API

Measurement

Advertiser API

Référence de l’API

Bien démarrer

Fondamentaux

Explorer

Disponible sur

Versions

Flux de travail

Capacités

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendez les capacités de ChatGPT et de Codex

Linux

Windows

Flux de travail de développement

Étendre et automatiser

Environnements

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Bien démarrer

ChatGPT Work

Identité et authentification

Accès à l’espace de travail, stratégies et modèles

Contrôles des plugins et des connecteurs

Utilisation, gouvernance et conformité

Déploiement et fournisseurs de modèles

Communauté

Blog

Communauté

Blog