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 produire presque tout type de réponse textuelle, qu’il s’agisse de code, d’équations mathématiques, de données structurées au format JSON ou de textes au style naturel.

Voici un exemple simple avec l’API Responses.

Générer 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, le tableau ne contient qu’un seul élément :

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 partez pas du principe que le texte généré par le modèle se trouve à l’emplacement output[0].content[0].text.

Certains de nos SDK officiels facilitent l’accès au texte en ajoutant aux réponses du modèle une propriété output_text qui regroupe toutes les sorties textuelles dans une seule chaîne. Vous pouvez ainsi récupérer directement le texte généré par le modèle.

Outre le texte brut, le modèle peut renvoyer des données structurées au format JSON grâce à la fonctionnalité de sorties structurées.

Voici un exemple simple avec l’API Chat Completions.

Générer 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, le tableau ne contient qu’un seul élément :

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

Outre le texte brut, le modèle peut renvoyer des données structurées au format JSON grâce à la fonctionnalité de sorties structurées.

Choix du modèle

Lorsque vous générez du contenu avec l’API, le choix du modèle est déterminant. Il correspond au paramètre model dans les exemples de code ci-dessus. Consultez la liste complète des modèles disponibles. Voici quelques critères pour choisir un modèle de génération de texte.

Les modèles de raisonnement génèrent une chaîne de raisonnement interne pour analyser le prompt. Ils excellent dans la compréhension de 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 performants. Ils donnent toutefois de meilleurs résultats lorsque vous leur expliquez plus précisément comment accomplir la tâche.
Les grands et les petits modèles (mini ou nano) offrent différents compromis entre vitesse, coût et capacité à résoudre des problèmes. Les grands modèles comprennent mieux les prompts et résolvent plus efficacement des problèmes dans des domaines variés. Les petits modèles sont généralement plus rapides et moins coûteux à utiliser.

En cas de doute, gpt-6-astra est un bon choix par défaut pour générer du texte à usage général et affiner vos 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 un contenu conforme à vos exigences.

Comme le contenu généré par un modèle n’est pas déterministe, rédiger un prompt pour obtenir le résultat souhaité demande à la fois de l’intuition et de la méthode. Certaines techniques et bonnes pratiques permettent toutefois d’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. Pour obtenir les meilleurs résultats, vous devrez parfois formuler vos prompts différemment selon que vous utilisez un modèle de raisonnement ou un modèle GPT, par exemple. Même deux versions d’un modèle de la même famille peuvent produire des résultats différents. Lorsque vous développez des applications plus complexes, nous vous recommandons vivement de suivre ces pratiques :

Configurez vos applications de production pour qu’elles utilisent des versions précises des modèles (par exemple gpt-4.1-2025-04-14) afin de garantir un comportement stable.
Créez des tests et des suites d’évaluation qui mesurent les effets de vos prompts. Vous pourrez ainsi suivre les performances à mesure que vous affinez vos prompts, changez de version de modèle ou passez à une version plus récente.

Voyons maintenant quelques outils et techniques pour construire vos prompts.

Rôles des messages et respect des instructions

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

Le paramètre instructions donne au modèle des consignes générales sur la manière de répondre, notamment le ton à adopter, les objectifs à atteindre et des exemples de réponses correctes. Les instructions fournies de cette manière sont prioritaires sur le prompt transmis dans le paramètre input.

Générer du texte à partir d’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 à transmettre les messages suivants dans le tableau input :

Générer 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?"
            }
        ]
    }'

Le paramètre instructions s’applique uniquement à 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, le contexte ne contient pas les instructions des échanges précédents.

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

Générer 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 explique comment nos modèles déterminent la priorité des messages en fonction de leur rôle.

`developer`	`user`	`assistant`
Les messages `developer` contiennent les instructions du développeur de l’application. Ils sont prioritaires sur les messages `user`.	Les messages `user` contiennent les instructions de l’utilisateur final. Ils passent après les messages `developer`.	Les messages générés par le modèle ont le rôle `assistant`.

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

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

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

Gestion des versions de prompts dans le code

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

OpenAI abandonne progressivement les objets de prompt réutilisables dans l’API. À compter du 3 juin 2026, la création de prompts sera moins mise en avant. L’arrêt de v1/prompts est prévu le 30 novembre 2026. Consultez la page des fonctionnalités obsolètes pour connaître le calendrier à jour.

Pour vos nouveaux travaux d’ingénierie de prompts :

Regroupez les fonctions de construction des prompts dans un petit module à proximité de la fonctionnalité concernée.
Utilisez des arguments de fonction typés ou des schémas pour les valeurs dynamiques, comme les données client, les fichiers ou les options d’une tâche.
Transmettez directement les valeurs instructions et input ainsi générées à 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 de prompts avec votre système de déploiement. Pour un déploiement progressif, utilisez des indicateurs de fonctionnalité ou des paramètres de configuration.

Si votre intégration appelle déjà un prompt enregistré à partir de son identifiant ou de sa version, suivez le guide de migration des objets de prompt pour intégrer ce prompt à votre code.

Mise en forme des messages avec Markdown et XML

Lorsque vous rédigez des messages developer et user, associez la mise en forme Markdown et les balises XML pour aider le modèle à distinguer les différentes parties du prompt et des données de contexte.

Les titres et les listes Markdown permettent de délimiter les sections du prompt et d’en indiquer la hiérarchie au modèle. Ils peuvent aussi faciliter la lecture de vos prompts pendant le développement. Les balises XML permettent de marquer le début et la fin d’un contenu, par exemple un document de référence. Les attributs XML permettent également d’associer au contenu du prompt des métadonnées auxquelles vos instructions peuvent faire référence.

En général, un message développeur contient les sections suivantes, dans cet ordre. Le contenu et l’ordre les plus efficaces peuvent toutefois varier selon le modèle utilisé.

Identité : Décrivez la fonction de l’assistant, son style de communication et ses objectifs généraux.
Instructions : Expliquez au modèle comment produire la réponse attendue. Quelles règles doit-il suivre ? Que doit-il faire et que doit-il toujours éviter ? Ajoutez les sous-sections pertinentes pour votre cas d’usage, par exemple pour expliquer au modèle comment appeler des fonctions personnalisées.
Exemples : Fournissez des exemples d’entrées possibles et, pour chacune, la sortie attendue du modèle.
Contexte : Donnez au modèle les informations supplémentaires dont il pourrait avoir besoin pour répondre, par exemple des données privées ou propriétaires qui ne figurent pas dans ses données d’entraînement, ou d’autres données que vous jugez particulièrement pertinentes. Placez de préférence ce contenu vers la fin du prompt, car le contexte peut varier d’une requête de génération à l’autre.

L’exemple suivant combine Markdown et balises XML pour construire un message developer organisé en sections et illustré par des exemples.

Message développeur 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>

Envoyer un prompt pour générer du code avec 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éduction des coûts et de la latence grâce à la mise en cache des prompts

Lorsque vous construisez un message, placez autant que possible le contenu que vous comptez réutiliser dans vos requêtes API au début du prompt et parmi les premiers paramètres du corps JSON de la requête envoyée à Chat Completions ou à Responses. Vous profiterez ainsi pleinement des gains de coût et de latence liés à la mise en cache des prompts.

Apprentissage few-shot

L’apprentissage few-shot permet de guider un grand modèle de langage vers une nouvelle tâche en incluant quelques exemples d’entrées et de sorties dans le prompt, sans recourir à l’ajustement fin du modèle. Le modèle déduit implicitement la règle qui relie ces exemples et l’applique au prompt. Choisissez des exemples couvrant un éventail d’entrées possibles et indiquez les sorties attendues.

En général, vous fournissez les exemples dans un message developer de votre requête API. Voici un message developer dont les exemples montrent au modèle comment classer des avis clients selon le sentiment exprimé.

# Identité

Vous êtes un assistant qui classe de courts avis sur des produits en attribuant
à chacun l’une des étiquettes suivantes : Positive, Negative ou Neutral.

# Instructions

* Répondez par un seul mot, sans mise en forme ni commentaire.
* Selon le sentiment exprimé dans l’avis qui vous est soumis, répondez uniquement
  par « Positive », « Negative » ou « Neutral ».

# Exemples

<product_review id="example-1">
J’adore ce casque ! La qualité du son est incroyable !
</product_review>

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

<product_review id="example-2">
L’autonomie est correcte, mais les coussinets font bas de gamme.
</product_review>

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

<product_review id="example-3">
Le service client est catastrophique. Je n’achèterai plus jamais chez eux.
</product_review>

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

Ajout d’informations de contexte pertinentes

Il est souvent utile d’inclure dans le prompt des informations de contexte sur lesquelles le modèle pourra s’appuyer pour répondre. Voici deux raisons courantes de le faire :

Donner au modèle accès à des données propriétaires ou à d’autres données absentes de son jeu de données d’entraînement.
Limiter les sources de sa réponse aux ressources que vous jugez les plus utiles.

L’ajout d’un contexte pertinent à une requête de génération est parfois appelé génération augmentée par la recherche (RAG). Il existe plusieurs façons d’enrichir le contexte d’un prompt. Vous pouvez par exemple interroger une base de données vectorielle et inclure le texte obtenu dans le prompt, ou utiliser l’outil de recherche de fichiers intégré d’OpenAI pour générer du contenu à partir de documents importés.

Prise en compte de la fenêtre de contexte

Lors d’une requête de génération, le modèle ne peut traiter qu’une quantité limitée de données. Cette limite de mémoire, appelée fenêtre de contexte, se mesure en tokens, des unités qui représentent les données que vous transmettez, qu’il s’agisse de texte ou d’images.

La taille de la fenêtre de contexte varie selon le modèle. Elle va d’une centaine de milliers de tokens à un million pour les modèles GPT-4.1 les plus récents. Consultez la documentation des modèles pour connaître la taille de la fenêtre de contexte de chacun.

Rédaction 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 explicitent la logique à suivre et fournissent les données nécessaires à la tâche. Pour tirer le meilleur parti du dernier modèle, commencez par le guide de rédaction de prompts à jour.

GPT-6 Astra prompting guide

Rédigez des prompts efficaces pour le dernier modèle grâce aux recommandations à jour, aux exemples pratiques et aux notes de migration.

Bonnes pratiques de rédaction de prompts pour le dernier modèle

Pour une présentation complète et à jour, consultez les bonnes pratiques de rédaction de prompts pour le dernier modèle. Les conseils pratiques ci-dessous restent valables.

GPT-6 Astra

obtient de bons résultats aussi bien pour créer une interface de toutes pièces que pour contribuer à une vaste base de code existante. Pour obtenir les meilleurs résultats, nous recommandons les bibliothèques suivantes :

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

Création d’applications web de toutes pièces

GPT-5 peut générer la partie front-end d’une application web à partir d’un seul prompt, sans exemple. Voici un exemple de prompt :

123456Vous excellez en développement web et savez créer de toutes pièces, à partir d’un seul prompt, des sites visuellement remarquables, interactifs et innovants. Vous savez livrer des solutions de premier ordre en une seule étape.
Suivez ces quatre étapes :
Étape 1 : Créez une grille d’évaluation et affinez-la jusqu’à ce que vous ayez pleinement confiance en sa pertinence.
Étape 2 : Examinez tout ce qui fait la qualité d’une application web de premier ordre créée en une seule étape. Appuyez-vous sur cette analyse pour élaborer une grille &lt;ONE_SHOT_RUBRIC&gt; comprenant 5 à 7 catégories. Gardez cette grille confidentielle : elle est réservée à votre usage interne.
Étape 3 : Utilisez la grille pour améliorer la solution par itérations jusqu’à obtenir la meilleure réponse possible au prompt. Si la solution n’atteint pas le niveau d’exigence le plus élevé dans chaque catégorie, affinez-la et réessayez.
Étape 4 : Recherchez la simplicité tout en atteignant pleinement l’objectif et évitez les dépendances externes telles que Next.js ou React.

Intégration à une vaste base de code

Pour le développement front-end dans de grandes bases de code, nous avons obtenu les meilleurs résultats en incluant dans les prompts les catégories d’instructions suivantes :

Principes : Fixez des critères de qualité visuelle, utilisez des composants modulaires et réutilisables, et veillez à la cohérence du design.
Interface et expérience utilisateur : Précisez la typographie, les couleurs, les espacements, 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 : Donnez des exemples de composants enveloppants réutilisables et expliquez comment isoler les appels au back-end.
Pages : Fournissez des modèles pour les mises en page courantes.
Instructions à 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 différents états et de documenter le code.

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

Pour les tâches confiées à un agent et les exécutions de longue durée avec gpt-6-astra, centrez vos prompts sur trois pratiques : demandez à l’agent de planifier ses tâches en détail pour traiter la demande dans son intégralité, d’expliquer les décisions importantes avant d’utiliser un outil et de suivre les étapes du workflow et leur avancement avec un outil de gestion des tâches.

Planification et persévérance Demandez au modèle de traiter la demande dans son intégralité avant de rendre la main. Il doit la décomposer en sous-tâches et, après chaque appel d’outil, examiner le résultat pour vérifier ce qu’il reste à accomplir. Dans l’exemple suivant, l’agent doit aussi attendre que l’utilisateur lui confirme qu’il a terminé avant de mettre fin à l’appel.

Gardez à l’esprit que vous êtes un agent. Traitez la demande de l’utilisateur
jusqu’au bout avant de terminer votre tour et de lui rendre la main.
Décomposez sa demande en toutes les sous-tâches nécessaires et vérifiez que
vous avez accompli chacune d’elles. Ne vous arrêtez pas après avoir traité
seulement une partie de la demande. Ne terminez votre tour que lorsque vous
avez la certitude d’avoir résolu le problème. Préparez-vous à répondre à
plusieurs demandes. Attendez que l’utilisateur vous confirme qu’il a terminé
avant de mettre fin à l’appel.

Avant tout nouvel appel de fonction, planifiez en détail la suite de votre
travail en suivant les étapes prévues. Après chaque appel de fonction,
examinez attentivement ses résultats pour vous assurer que vous avez
entièrement traité la demande de l’utilisateur et toutes les sous-tâches
qui en découlent.

Explication des appels d’outils

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

Avant d’appeler un outil, expliquez pourquoi vous l’appelez.

Suivi de l’avancement avec des grilles d’évaluation et des listes de tâches

Utilisez un outil de gestion de liste de tâches ou une grille d’évaluation pour structurer la planification et éviter d’oublier des étapes.

Pour des recommandations détaillées et des exemples de prompts pour la création d’agents, consultez les bonnes pratiques de rédaction de prompts pour le dernier modèle.

Rédaction de prompts pour les modèles de raisonnement

La manière de rédiger un prompt diffère selon que vous utilisez un modèle de raisonnement ou un modèle GPT. En général, les modèles de raisonnement obtiennent de meilleurs résultats lorsque vous vous limitez à des consignes générales. Les modèles GPT, eux, tirent parti d’instructions très précises.

Pour vous représenter cette différence, imaginez deux collègues :

Un modèle de raisonnement ressemble à un collègue expérimenté. Vous pouvez lui donner un objectif et lui faire confiance pour déterminer comment l’atteindre.
Un modèle GPT ressemble à un collègue débutant. Il obtiendra de meilleurs résultats si vous lui donnez des instructions explicites pour produire le résultat attendu.

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 approfondir le sujet avec les ressources suivantes.

Créer un prompt dans le Playground

Utilisez le Playground pour rédiger et affiner vos prompts.

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

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

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

Retrouvez 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. Il propose des exemples de code ainsi que des liens vers des ressources tierces :

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès