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 JSON structurées ou de textes qui semblent écrits par une personne.
Utilisez l’API Responses pour envoyer des requêtes directement au modèle, comme dans cet exemple de génération de texte.
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 qui regroupe les éléments 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 inclure 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. Rien ne garantit que le texte généré par le modèle se trouve dans output[0].content[0].text.
Certains de nos SDK officiels facilitent l’accès au texte généré en ajoutant aux réponses du modèle une propriété output_text. Elle regroupe toutes les sorties textuelles du modèle dans une seule chaîne de caractères.
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é de sorties structurées.
L’ingénierie de prompts consiste à rédiger des instructions efficaces pour qu’un modèle génère de manière fiable du contenu qui répond à vos exigences.
Comme la génération de contenu par un modèle n’est pas déterministe, la rédaction d’un prompt qui produit le résultat souhaité relève à la fois de l’art et de la science. Certaines techniques et bonnes pratiques permettent néanmoins 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 toutefois parfois adapter vos prompts au modèle choisi. Même deux versions figées d’un modèle de la même famille peuvent donner des résultats différents. Lorsque vous développez des applications plus complexes, nous vous recommandons donc vivement de suivre ces pratiques :
- Configurez vos applications de production pour qu’elles utilisent des versions figées précises des modèles (par exemple
gpt-5.5-2026-04-23) afin de garantir un comportement stable.
- Créez des tests et des suites d’évaluation pour mesurer les effets de vos prompts et suivre leurs performances au fil des modifications ou lorsque vous changez de version du modèle, notamment lors d’une mise à niveau.
Voyons quels outils et techniques vous pouvez utiliser pour construire vos prompts.
OpenAI propose de nombreux modèles et plusieurs API. Les modèles de raisonnement, comme gpt-6-astra, se comportent différemment des modèles conversationnels. Les prompts les plus efficaces ne sont donc pas les mêmes. Avec l’API Responses, les modèles de raisonnement sont plus performants et font preuve de meilleures capacités intellectuelles.
Pour toute application de génération de texte, nous vous recommandons de privilégier l’API Responses par rapport à l’API Chat Completions, plus ancienne. Si vous utilisez un modèle de raisonnement, il est particulièrement intéressant de migrer vers l’API Responses.
Vous pouvez donner au modèle des instructions ayant différents niveaux d’autorité en combinant le paramètre instructions de l’API et les rôles des messages.
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. Ces instructions ont priorité sur le prompt fourni dans le paramètre input.
1
2
3
4
5
6
7
8
9
10
11import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6-astra",
reasoning: { effort: "low" },
instructions: "Talk like a pirate.",
input: "Are semicolons optional in JavaScript?",
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
instructions="Talk like a pirate.",
input="Are semicolons optional in JavaScript?",
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Instructions: openai.String("Talk like a pirate."),
Reasoning: responses.ReasoningParam{
Effort: responses.ReasoningEffortLow,
},
Input: responses.ResponseNewParamsInputUnion{
OfString: openai.String("Are semicolons optional in JavaScript?"),
},
})
if err != nil {
panic(err)
}
fmt.Println(response.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.ResponseCreateParams;
String semicolonsDevMsg = "Talk like a pirate.";
String semicolonsPrompt = "Are semicolons optional in JavaScript?";
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input(semicolonsPrompt)
.instructions(semicolonsDevMsg)
.reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
.build();
client.responses().create(params).output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22using OpenAI.Responses;
#pragma warning disable OPENAI001
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);
CreateResponseOptions options = new()
{
Model = "gpt-6-astra",
Instructions = "Talk like a pirate.",
ReasoningOptions = new ResponseReasoningOptions
{
ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
},
};
options.InputItems.Add(
ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);
ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11require "openai"
client = OpenAI::Client.new
response = client.responses.create(
model: "gpt-6-astra",
instructions: "Talk like a pirate.",
reasoning: { effort: :low },
input: "Are semicolons optional in JavaScript?"
)
puts(response.output_text)
1
2
3
4
5
6
7
8
9curl "https://api.openai.com/v1/responses" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"reasoning": {"effort": "low"},
"instructions": "Talk like a pirate.",
"input": "Are semicolons optional in JavaScript?"
}'
L’exemple ci-dessus revient à peu près à fournir les messages suivants dans le tableau input :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6-astra",
reasoning: { effort: "low" },
input: [
{
role: "developer",
content: "Talk like a pirate.",
},
{
role: "user",
content: "Are semicolons optional in JavaScript?",
},
],
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
input=[
{"role": "developer", "content": "Talk like a pirate."},
{"role": "user", "content": "Are semicolons optional in JavaScript?"},
],
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Reasoning: responses.ReasoningParam{
Effort: responses.ReasoningEffortLow,
},
Input: responses.ResponseNewParamsInputUnion{
OfInputItemList: responses.ResponseInputParam{
responses.ResponseInputItemParamOfMessage(
"Talk like a pirate.",
responses.EasyInputMessageRoleDeveloper,
),
responses.ResponseInputItemParamOfMessage(
"Are semicolons optional in JavaScript?",
responses.EasyInputMessageRoleUser,
),
},
},
})
if err != nil {
panic(err)
}
fmt.Println(response.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
String semicolonsDevMsg = "Talk like a pirate.";
String semicolonsPrompt = "Are semicolons optional in JavaScript?";
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input(
ResponseCreateParams.Input.ofResponse(
List.of(
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.DEVELOPER)
.content(semicolonsDevMsg)
.build()),
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.USER)
.content(semicolonsPrompt)
.build()))))
.reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
.build();
client.responses().create(params).output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);
CreateResponseOptions options = new()
{
Model = "gpt-6-astra",
ReasoningOptions = new ResponseReasoningOptions
{
ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
},
};
options.InputItems.Add(
ResponseItem.CreateDeveloperMessageItem("Talk like a pirate.")
);
options.InputItems.Add(
ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);
ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19require "openai"
client = OpenAI::Client.new
response = client.responses.create(
model: "gpt-6-astra",
reasoning: { effort: :low },
input: [
{
role: :developer,
content: "Talk like a pirate."
},
{
role: :user,
content: "Are semicolons optional in JavaScript?"
}
]
)
puts(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17curl "https://api.openai.com/v1/responses" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"reasoning": {"effort": "low"},
"input": [
{
"role": "developer",
"content": "Talk like a pirate."
},
{
"role": "user",
"content": "Are semicolons optional in JavaScript?"
}
]
}'
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.
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 ont priorité sur les messages de l’utilisateur. | Les messages user contiennent les instructions de l’utilisateur final.
Leur priorité est inférieure à celle des messages du développeur. | 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 contenu fournis par vous ou par le modèle. Pour en savoir plus, consultez le guide sur la gestion de l’état de la conversation.
Dans un langage de programmation, la relation entre une fonction et ses arguments est comparable à celle entre les messages developer et user.
- Les messages
developer définissent les règles et la logique métier du système, comme la définition d’une fonction.
- Les messages
user fournissent les entrées et les paramètres de configuration auxquels s’appliquent les instructions du message developer, comme les arguments passés à une fonction.
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 utiliser des entrées typées, la revue de code, les tests et votre processus de déploiement habituel pour modifier le comportement du modèle.
OpenAI retire progressivement les objets de prompt réutilisables de 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 en fin de vie pour connaître le calendrier à jour.
Pour vos nouveaux développements en génération de texte, suivez ces pratiques :
- Regroupez les fonctions de construction des prompts dans un petit module à proximité de la fonctionnalité qui les utilise.
- Utilisez des arguments de fonction typés ou des schémas pour les valeurs dynamiques, comme les données clients, les fichiers ou les options d’une tâche.
- 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 vos prompts de production.
- Déployez les modifications de vos prompts avec votre système de déploiement. Pour un déploiement par étapes, utilisez des indicateurs de fonctionnalité ou des paramètres de configuration.
Si votre intégration appelle déjà un prompt enregistré en indiquant son identifiant ou sa version, suivez le guide de migration des objets de prompt pour intégrer ce prompt à votre code.
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 un modèle respectent un schéma JSON.
Documentation de référence complète de l’API
Consultez la documentation de référence de l’API pour découvrir toutes les options de génération de texte.
