Com a API da OpenAI, você pode usar um LLM para gerar texto a partir de um prompt, assim como faria no ChatGPT. Os modelos podem gerar praticamente qualquer tipo de resposta em texto, como código, equações matemáticas, dados estruturados em JSON ou prosa semelhante à escrita humana.
Use a Responses API para fazer solicitações diretas ao modelo, como esta chamada de geração de texto.
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."
}'
A propriedade output da resposta contém um array com o conteúdo gerado pelo modelo. Neste exemplo simples, há apenas uma saída, como esta:
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": []
}
]
}
]
O array output costuma ter mais de um item! Ele pode conter chamadas de ferramentas, dados sobre tokens de raciocínio gerados por modelos de raciocínio e outros itens. Não é seguro presumir que a saída de texto do modelo esteja em output[0].content[0].text.
Alguns dos nossos SDKs oficiais incluem, por conveniência, uma propriedade output_text nas respostas dos modelos, que reúne todas as saídas de texto do modelo em uma única string. Isso pode ser útil como um atalho para acessar a saída de texto do modelo.
Além de texto simples, você também pode fazer o modelo retornar dados estruturados em formato JSON. Esse recurso se chama Saídas estruturadas.
Engenharia de prompt é o processo de escrever instruções eficazes para um modelo, para que ele gere de forma consistente conteúdo que atenda aos seus requisitos.
Como o conteúdo gerado por um modelo não é determinístico, criar prompts para obter o resultado desejado é uma mistura de arte e ciência. No entanto, você pode aplicar técnicas e práticas recomendadas para obter bons resultados de forma consistente.
Algumas técnicas de engenharia de prompt funcionam com qualquer modelo, como o uso de papéis de mensagem. Mas modelos diferentes podem precisar de prompts diferentes para produzir os melhores resultados. Até snapshots diferentes de modelos da mesma família podem produzir resultados distintos. Por isso, ao desenvolver aplicativos mais complexos, recomendamos fortemente:
- Fixar seus aplicativos de produção em snapshots de modelos específicos (como
gpt-5.5-2026-04-23, por exemplo) para garantir um comportamento consistente
- Criar testes e conjuntos de avaliações que meçam o comportamento dos prompts para monitorar o desempenho à medida que você faz ajustes ou troca e atualiza versões dos modelos
Agora, vamos examinar algumas ferramentas e técnicas disponíveis para criar prompts.
A OpenAI oferece diversos modelos e várias APIs para você escolher. Modelos de raciocínio, como gpt-6-astra, se comportam de forma diferente dos modelos de chat e respondem melhor a outros tipos de prompt. Um ponto importante é que os modelos de raciocínio têm melhor desempenho e demonstram maior inteligência quando usados com a Responses API.
Se você está desenvolvendo um aplicativo de geração de texto, recomendamos usar a Responses API em vez da API chat completions, que é mais antiga. E, se você usa um modelo de raciocínio, é especialmente útil migrar para a Responses.
Você pode fornecer instruções ao modelo com diferentes níveis de autoridade usando o parâmetro instructions da API junto com os papéis de mensagem.
O parâmetro instructions fornece ao modelo instruções gerais sobre como ele deve se comportar ao gerar uma resposta, incluindo tom, objetivos e exemplos de respostas corretas. As instruções fornecidas dessa forma têm prioridade sobre um prompt no parâmetro 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?"
}'
O exemplo acima é aproximadamente equivalente a usar as seguintes mensagens de entrada no array 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?"
}
]
}'
Observe que o parâmetro instructions se aplica apenas à solicitação atual de geração de resposta. Se você estiver gerenciando o estado da conversa com o parâmetro previous_response_id, as instruções de instructions usadas nos turnos anteriores não estarão presentes no contexto.
A especificação do modelo da OpenAI descreve como nossos modelos atribuem diferentes níveis de prioridade a mensagens com diferentes papéis.
| developer |
user |
assistant |
|---|
As mensagens developer são instruções fornecidas pelo desenvolvedor
do aplicativo e têm prioridade sobre as mensagens do usuário. | As mensagens user são instruções fornecidas por um usuário final e têm prioridade
inferior à das mensagens do desenvolvedor. | As mensagens geradas pelo modelo têm o papel assistant. |
Uma conversa com vários turnos pode incluir diversas mensagens desses tipos, além de outros tipos de conteúdo fornecidos tanto por você quanto pelo modelo. Saiba mais sobre como gerenciar o estado da conversa aqui.
Você pode pensar nas mensagens developer e user como uma função e seus argumentos em uma linguagem de programação.
- As mensagens
developer fornecem as regras e a lógica de negócios do sistema, como a definição de uma função.
- As mensagens
user fornecem entradas e configurações às quais as instruções da mensagem developer são aplicadas, como os argumentos de uma função.
Armazene os prompts de produção no código do seu aplicativo em vez de criar objetos de prompt reutilizáveis. Gerenciar prompts no código permite usar entradas tipadas, revisão de código, testes e seu processo habitual de implantação para alterar o comportamento do modelo.
A OpenAI está descontinuando os objetos de prompt reutilizáveis na API. A criação de prompts receberá
menos destaque a partir de 3 de junho de 2026, e o encerramento de v1/prompts está previsto
para 30 de novembro de 2026. Consulte a página de
descontinuações para ver o cronograma
atual.
Para novos trabalhos de geração de texto:
- Mantenha as funções que criam prompts em um módulo pequeno, próximo à funcionalidade que atendem.
- Use argumentos de função tipados ou esquemas para valores dinâmicos, como dados de clientes, arquivos ou opções de tarefas.
- Passe os valores gerados de
instructions e input diretamente para a Responses API.
- Adicione dados de teste representativos, testes e verificações de avaliação antes de alterar os prompts de produção.
- Distribua as alterações de prompts pelo seu sistema de implantação, usando sinalizadores de funcionalidades ou configurações quando precisar fazer lançamentos em etapas.
Se sua integração já chama um prompt salvo por meio de um ID ou uma versão de prompt, use o guia de migração de objetos de prompt para mover esse prompt para o código.
Agora que você conhece os conceitos básicos de entradas e saídas de texto, pode explorar um destes recursos a seguir.
Crie um prompt no Playground
Use o Playground para desenvolver e aprimorar prompts.
Gere dados JSON com saídas estruturadas
Garanta que os dados JSON gerados por um modelo estejam em conformidade com um esquema JSON.
Referência completa da API
Confira todas as opções de geração de texto na referência da API.
