Con la API de OpenAI, puedes usar un modelo de lenguaje de gran tamaño para generar texto a partir de un prompt, como lo harías con ChatGPT. Los modelos pueden generar casi cualquier tipo de respuesta de texto, como código, ecuaciones matemáticas, datos JSON estructurados o prosa similar a la escrita por una persona.
Usa la API Responses para hacer solicitudes directas al modelo, como esta llamada de generación 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."
}'
La propiedad output de la respuesta contiene un arreglo con el contenido generado por el modelo. En este ejemplo sencillo, tenemos un solo resultado, que se ve así:
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": []
}
]
}
]
¡El arreglo output suele tener más de un elemento! Puede contener llamadas a herramientas, datos sobre los tokens de razonamiento generados por los modelos de razonamiento y otros elementos. No es seguro asumir que el texto generado por el modelo se encuentra en output[0].content[0].text.
Algunos de nuestros SDK oficiales incluyen una propiedad output_text en las respuestas del modelo para facilitar su uso. Esta propiedad reúne todo el texto generado por el modelo en una sola cadena. Puede ser útil como una forma rápida de acceder al texto generado por el modelo.
Además de texto sin formato, también puedes hacer que el modelo devuelva datos estructurados en formato JSON. Esta función se llama resultados estructurados.
La ingeniería de prompts es el proceso de redactar instrucciones eficaces para un modelo, de modo que genere de manera consistente contenido que cumpla con tus requisitos.
Como el contenido generado por un modelo no es determinista, diseñar prompts para obtener el resultado deseado combina arte y ciencia. Sin embargo, puedes aplicar técnicas y prácticas recomendadas para obtener buenos resultados de manera consistente.
Algunas técnicas de ingeniería de prompts funcionan con todos los modelos, como el uso de roles de mensajes. Pero distintos modelos pueden necesitar prompts diferentes para producir los mejores resultados. Incluso distintas versiones de modelos de una misma familia podrían producir resultados diferentes. Por eso, a medida que desarrolles aplicaciones más complejas, te recomendamos enfáticamente:
- Fijar tus aplicaciones de producción a versiones específicas de los modelos (como
gpt-5.5-2026-04-23, por ejemplo) para garantizar un comportamiento consistente
- Crear pruebas y conjuntos de evaluaciones que midan el comportamiento de los prompts para que puedas monitorear el rendimiento a medida que iteras, o cuando cambies y actualices las versiones de los modelos
Ahora, veamos algunas herramientas y técnicas que tienes a tu disposición para crear prompts.
OpenAI ofrece muchos modelos diferentes y varias API para elegir. Los modelos de razonamiento, como gpt-6-astra, se comportan de manera distinta a los modelos de chat y responden mejor a otros tipos de prompts. Ten en cuenta que los modelos de razonamiento rinden mejor y demuestran una mayor inteligencia cuando se usan con la API Responses.
Si estás desarrollando una aplicación de generación de texto, te recomendamos usar la API Responses en lugar de la API para completar chats, que es más antigua. Y si usas un modelo de razonamiento, resulta especialmente útil migrar a Responses.
Puedes darle instrucciones al modelo con distintos niveles de autoridad usando el parámetro instructions de la API junto con los roles de mensajes.
El parámetro instructions le da al modelo instrucciones generales sobre cómo debe comportarse al generar una respuesta, incluidos el tono, los objetivos y ejemplos de respuestas correctas. Las instrucciones proporcionadas de esta manera tendrán prioridad sobre un prompt en el 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?"
}'
El ejemplo anterior es aproximadamente equivalente a usar los siguientes mensajes de entrada en el arreglo 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?"
}
]
}'
Ten en cuenta que el parámetro instructions solo se aplica a la solicitud actual de generación de respuestas. Si administras el estado de la conversación con el parámetro previous_response_id, las instrucciones de instructions usadas en turnos anteriores no estarán presentes en el contexto.
Las especificaciones del modelo de OpenAI describen cómo nuestros modelos asignan distintos niveles de prioridad a los mensajes según su rol.
| developer |
user |
assistant |
|---|
Los mensajes developer son instrucciones proporcionadas por el desarrollador
de la aplicación y tienen prioridad sobre los mensajes del usuario. | Los mensajes user son instrucciones proporcionadas por un usuario final y tienen
menor prioridad que los mensajes del desarrollador. | Los mensajes generados por el modelo tienen el rol assistant. |
Una conversación de varios turnos puede incluir varios mensajes de estos tipos, junto con otros tipos de contenido proporcionados tanto por ti como por el modelo. Obtén más información sobre cómo administrar el estado de la conversación aquí.
Puedes pensar en los mensajes developer y user como una función y sus argumentos en un lenguaje de programación.
- Los mensajes
developer proporcionan las reglas y la lógica de negocio del sistema, como la definición de una función.
- Los mensajes
user proporcionan las entradas y la configuración a las que se aplican las instrucciones del mensaje developer, como los argumentos de una función.
Almacena los prompts de producción en el código de tu aplicación en lugar de crear objetos de prompt reutilizables. Gestionar los prompts en el código te permite usar entradas tipadas, revisión de código, pruebas y tu proceso habitual de despliegue para cambiar el comportamiento del modelo.
OpenAI está dejando de admitir los objetos de prompt reutilizables en la API. La creación de prompts
pasará a un segundo plano a partir del 3 de junio de 2026, y está previsto que v1/prompts deje de funcionar
el 30 de noviembre de 2026. Consulta la página de funciones
obsoletas para conocer el cronograma
actual.
Para nuevos desarrollos de generación de texto:
- Mantén los constructores de prompts en un módulo pequeño cerca de la funcionalidad a la que sirven.
- Usa argumentos de función tipados o esquemas para los valores dinámicos, como datos de clientes, archivos u opciones de tareas.
- Pasa los valores generados de
instructions y input directamente a la API Responses.
- Agrega fixtures representativos, pruebas y verificaciones de evaluación antes de cambiar los prompts de producción.
- Despliega los cambios en los prompts a través de tu sistema de despliegue, usando indicadores de funcionalidades o ajustes de configuración cuando necesites lanzamientos por etapas.
Si tu integración ya llama a un prompt guardado mediante un ID o una versión, usa la guía de migración de objetos de prompt para trasladar ese prompt al código.
Ahora que conoces los conceptos básicos de las entradas y salidas de texto, puedes consultar alguno de estos recursos.
Crea un prompt en el Playground
Usa el Playground para desarrollar prompts e iterar sobre ellos.
Genera datos JSON con resultados estructurados
Asegúrate de que los datos JSON generados por un modelo se ajusten a un esquema JSON.
Referencia completa de la API
Consulta todas las opciones de generación de texto en la referencia de la API.
