Écrire, relire et modifier du code, ainsi que répondre à des questions à son sujet, fait aujourd’hui partie des principaux cas d’utilisation des modèles OpenAI. Ce guide présente les options de génération de code avec gpt-6-astra et Codex.
Codex est l’agent de programmation d’OpenAI pour le développement logiciel. Il vous aide à écrire, à relire et à déboguer du code. Interagissez avec Codex dans différentes interfaces : dans votre IDE, via la CLI, sur des sites web et mobiles, ou dans vos pipelines CI/CD à l’aide du SDK. Codex est le meilleur moyen de bénéficier du génie logiciel agentique dans vos projets.
Codex donne les meilleurs résultats avec les derniers modèles généralistes, comme gpt-5.6. Nous proposons une gamme de modèles spécialement conçus pour fonctionner avec des agents de programmation comme Codex, notamment gpt-5.3-codex, mais nous recommandons d’utiliser le dernier modèle généraliste pour la plupart des tâches de génération de code.
Consultez la documentation ChatGPT pour accéder aux guides de configuration, aux documents de référence, aux tarifs et à d’autres informations.
Pour la plupart des tâches de génération de code via l’API, commencez par gpt-6-astra. Il prend en charge aussi bien les tâches généralistes que la programmation. C’est donc un bon choix par défaut lorsque votre application doit écrire du code, raisonner sur les exigences, consulter la documentation et gérer des workflows plus larges au même endroit.
Cet exemple montre comment utiliser l’API Responses pour un cas d’utilisation de génération de code :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import OpenAI from "openai";
const openai = new OpenAI();
const result = await openai.responses.create({
model: "gpt-6-astra",
input: `Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))
`,
reasoning: { effort: "high" },
});
console.log(result.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17from openai import OpenAI
client = OpenAI()
result = client.responses.create(
model="gpt-6-astra",
input="""Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))
""",
reasoning={"effort": "high"},
)
print(result.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
28package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
"github.com/openai/openai-go/v3/shared"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(`Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))`)},
Reasoning: shared.ReasoningParam{Effort: shared.ReasoningEffortHigh},
})
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
26import 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 code =
"""
def display_name(user):
return user.profile.name
print(display_name(None))
""";
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input("Find the null pointer exception in this code:\n\n" + code)
.reasoning(Reasoning.builder().effort(ReasoningEffort.HIGH).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
24
25
26
27
28
29using 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.High,
},
};
options.InputItems.Add(
ResponseItem.CreateUserMessageItem(
"""
Find the null pointer exception in this code:
def display_name(user):
return user.profile.name
print(display_name(None))
"""
)
);
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
17require "openai"
client = OpenAI::Client.new
code = <<~PYTHON
def display_name(user):
return user.profile.name
print(display_name(None))
PYTHON
response = client.responses.create(
model: "gpt-6-astra",
input: "Find the null pointer exception in this code:\n\n#{code}",
reasoning: { effort: :high }
)
puts(response.output_text)
1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"input": "Find the null pointer exception in this code:\n\ndef display_name(user):\n return user.profile.name\n\nprint(display_name(None))\n",
"reasoning": { "effort": "high" }
}'
Nos modèles de la famille GPT-5 sont particulièrement performants en développement frontend, notamment lorsqu’ils sont associés à un harnais d’agent de programmation comme Codex.
Les applications de démonstration ci-dessous ont été générées en une seule étape, c’est-à-dire à partir d’un seul prompt, sans code écrit à la main. Utilisez-les pour évaluer la qualité de la génération frontend et les formulations de prompts adaptées aux workflows de génération de code axés sur les interfaces utilisateur.
- Consultez la documentation de ChatGPT pour découvrir les possibilités de Codex, le configurer dans l’interface de votre choix ou obtenir plus de détails.
- Consultez les recommandations sur les modèles pour en savoir plus sur le choix des modèles, leurs fonctionnalités, la migration et les techniques de conception de prompts adaptées aux tâches de programmation et aux tâches agentiques.
- Comparez
gpt-6-astra et gpt-5.3-codex sur les pages des modèles.
