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 des textes rédigés dans un style naturel.
Utilisez l’API Responses pour envoyer des requêtes directement au modèle, comme cet appel 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 des contenus générés par le modèle. Dans cet exemple simple, nous n’avons qu’un seul élément de sortie, 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 dans 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 tous les textes générés par le modèle dans une seule chaîne de caractères. Elle peut ainsi servir de raccourci pour accéder au texte généré par le modèle.
En plus du texte brut, vous pouvez demander au modèle de renvoyer des données structurées au format JSON. Cette fonctionnalité s’appelle 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 constante du contenu qui répond à vos exigences.
Le contenu généré par un modèle étant non déterministe, rédiger des prompts pour obtenir le résultat souhaité relève à la fois de l’art et de la science. Vous pouvez toutefois appliquer des techniques et des bonnes pratiques pour obtenir de bons résultats de manière constante.
Certaines techniques d’ingénierie de prompts fonctionnent avec tous les modèles, comme l’utilisation des rôles de message. Mais pour obtenir les meilleurs résultats, il peut être nécessaire d’adapter les prompts à chaque modèle. Même différentes versions figées de modèles d’une même famille peuvent produire 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 en production pour utiliser des versions figées de modèles précises (comme
gpt-5.5-2026-04-23) afin de garantir un comportement constant
- 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.
OpenAI propose un large choix de modèles et plusieurs API. Les modèles de raisonnement, comme gpt-6-astra, se comportent différemment des modèles de discussion et donnent de meilleurs résultats avec des prompts adaptés. Retenez notamment que les modèles de raisonnement sont plus performants et font preuve d’une intelligence supérieure lorsqu’ils sont utilisés avec l’API Responses.
Pour toute application de génération de texte, nous recommandons l’API Responses plutôt que l’ancienne API Chat Completions. Si vous utilisez un modèle de raisonnement, il est particulièrement utile de migrer vers Responses.
Vous pouvez fournir au modèle des instructions ayant différents niveaux d’autorité en utilisant le paramètre d’API instructions ainsi que les rôles des messages.
Le paramètre instructions fournit au modèle des instructions générales sur le comportement à adopter lors de la génération d’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.
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 :
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 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 utilisées lors des échanges précédents ne seront pas présentes dans le contexte.
La spécification du modèle 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 utilisateur. | Les messages user sont des instructions fournies par un 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 à plusieurs échanges 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 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.
Stockez les prompts de production dans le code de votre application au lieu de créer des objets prompt réutilisables. La gestion des prompts dans le code vous permet de vous appuyer sur 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 déprécie 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
le 30 novembre 2026. Consultez la page des
dépréciations pour connaître le calendrier
à jour.
Pour vos nouveaux développements de génération de texte :
- 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, comme les données client, les fichiers ou les options de tâche.
- Transmettez les valeurs générées de
instructions et de 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 avec votre système de déploiement, en utilisant des indicateurs de fonctionnalité ou la configuration lorsque 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, utilisez le guide de migration des objets prompt pour transférer ce prompt dans le code.
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 développer et affiner vos prompts.
Générez 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.
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.
