La programmation est aujourd’hui l’un des principaux cas d’usage des modèles d’OpenAI. Ils peuvent écrire du code, en faire la revue, le modifier et répondre à des questions à son sujet. Ce guide présente les différentes façons de générer du code avec gpt-6-astra et Codex.
Codex est l’agent de programmation d’OpenAI pour le développement logiciel. Il vous aide à écrire du code, à en faire la revue et à le déboguer. Vous pouvez utiliser Codex dans différentes interfaces : dans votre IDE, via la CLI, sur les sites Web et mobiles ou dans vos pipelines CI/CD grâce au SDK. Codex est le meilleur moyen de confier des tâches de développement logiciel à des agents dans vos projets.
Codex donne les meilleurs résultats avec les modèles généralistes les plus récents, comme gpt-6.1-sol.
Consultez la documentation de ChatGPT pour accéder aux guides de configuration, à la documentation 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. Ce modèle convient aussi bien aux tâches générales qu’à la programmation. C’est un bon choix par défaut si votre application doit à la fois écrire du code, analyser des exigences, consulter la documentation et prendre en charge des workflows plus larges.
Cet exemple montre comment utiliser l’API Responses pour générer du 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" }
}'
Pour le développement frontend, commencez par utiliser gpt-6.1-sol ou gpt-6-astra dans Codex ou via l’API Responses.
La galerie historique de GPT-5 présente des applications générées chacune à partir d’un seul prompt. Prenez ces prompts comme points de départ et évaluez les résultats avec le modèle que vous prévoyez de déployer.
- 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 le guide des modèles pour choisir un modèle, découvrir ses fonctionnalités, préparer une migration et trouver des formulations de prompts efficaces pour la programmation et les tâches confiées à des agents.
- Comparez
gpt-6-astra et gpt-6.1-sol sur leurs pages respectives.
