Ingeniería de prompts

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 que escribiría una persona.

Aquí tienes un ejemplo sencillo con la API Responses.

Genera texto a partir de un prompt sencillo

JavaScript

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, hay 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 contener más de un elemento! Puede incluir llamadas a herramientas, datos sobre los tokens de razonamiento generados por los modelos de razonamiento y otros elementos. No es seguro suponer que el texto generado por el modelo se encuentra en output[0].content[0].text.

Algunos de nuestros SDK oficiales incluyen, para mayor comodidad, una propiedad output_text en las respuestas del modelo que reúne todo el texto generado en una sola cadena. Esta propiedad puede ser útil para acceder directamente 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.

Aquí tienes un ejemplo sencillo con la API para completar chats.

Genera texto a partir de un prompt sencillo

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14import OpenAI from "openai";
const client = new OpenAI();

const completion = await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [
    {
      role: "user",
      content: "Write a one-sentence bedtime story about a unicorn.",
    },
  ],
});

console.log(completion.choices[0].message.content);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": "Write a one-sentence bedtime story about a unicorn.",
        }
    ],
)

print(completion.choices[0].message.content)

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
27package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	completion, err := client.Chat.Completions.New(
		context.Background(),
		openai.ChatCompletionNewParams{
			Model: "gpt-6-astra",
			Messages: []openai.ChatCompletionMessageParamUnion{
				openai.UserMessage("Write a one-sentence bedtime story about a unicorn."),
			},
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addUserMessage("Write a one-sentence bedtime story about a unicorn.")
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11using OpenAI.Chat;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

ChatCompletion completion = await client.CompleteChatAsync(
    new UserChatMessage("Write a one-sentence bedtime story about a unicorn.")
);

Console.WriteLine(completion.Content[0].Text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14require "openai"

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: "Write a one-sentence bedtime story about a unicorn."
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-5.5",
        "messages": [
            {
                "role": "user",
                "content": "Write a one-sentence bedtime story about a unicorn."
            }
        ]
    }'

La propiedad choices de la respuesta contiene un arreglo con el contenido generado por el modelo. En este ejemplo sencillo, hay un solo resultado, que se ve así:

123456789101112[
  {
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.",
      "refusal": null
    },
    "logprobs": null,
    "finish_reason": "stop"
  }
]

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.

Elegir un modelo

Una decisión clave al generar contenido mediante la API es qué modelo usar: se especifica con el parámetro model de los ejemplos de código anteriores. Aquí puedes encontrar la lista completa de modelos disponibles. Estos son algunos factores que debes considerar al elegir un modelo para generar texto.

Los modelos de razonamiento generan una cadena de pensamiento interna para analizar el prompt de entrada y se destacan por comprender tareas complejas y planificar en varios pasos. Por lo general, también son más lentos y más costosos de usar que los modelos GPT.
Los modelos GPT son rápidos, rentables y muy inteligentes, pero dan mejores resultados con instrucciones más explícitas sobre cómo realizar las tareas.
Los modelos grandes y pequeños (mini o nano) ofrecen distintas ventajas y desventajas en cuanto a velocidad, costo e inteligencia. Los modelos grandes son más eficaces para comprender prompts y resolver problemas en distintos ámbitos, mientras que los modelos pequeños suelen ser más rápidos y económicos de usar.

Si tienes dudas, gpt-6-astra es una buena opción predeterminada para generar texto de uso general y mejorar prompts de forma iterativa.

Ingeniería de prompts

La ingeniería de prompts es el proceso de escribir instrucciones eficaces para que un modelo genere de manera consistente contenido que cumpla 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, como el uso de roles de mensaje, funcionan con todos los modelos. Sin embargo, distintos tipos de modelos (como los de razonamiento y los GPT) pueden necesitar prompts diferentes para dar los mejores resultados. Incluso distintas instantáneas de modelos de la misma familia podrían producir resultados diferentes. Por eso, a medida que desarrolles aplicaciones más complejas, te recomendamos especialmente:

Fijar tus aplicaciones de producción a instantáneas específicas de los modelos (como gpt-4.1-2025-04-14, por ejemplo) para garantizar un comportamiento consistente
Crear pruebas y conjuntos de evaluación que midan el comportamiento de los prompts para que puedas monitorear el rendimiento a medida que los mejoras o cuando cambias o actualizas las versiones de los modelos

Ahora, veamos algunas herramientas y técnicas que tienes disponibles para crear prompts.

Roles de mensaje y seguimiento de instrucciones

Puedes darle al modelo instrucciones con distintos niveles de autoridad mediante el parámetro instructions de la API o los roles de mensaje.

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. Todas las instrucciones proporcionadas de esta manera tendrán prioridad sobre un prompt en el parámetro input.

Genera texto con instrucciones

JavaScript

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 equivale aproximadamente a usar los siguientes mensajes de entrada en el arreglo input:

Genera texto con mensajes de distintos roles

JavaScript

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 respuesta. 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.

Puedes darle al modelo instrucciones (prompts) con distintos niveles de autoridad mediante los roles de mensaje.

Genera texto con mensajes de distintos roles

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";
const client = new OpenAI();

const completion = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "developer",
      content: "Talk like a pirate.",
    },
    {
      role: "user",
      content: "Are semicolons optional in JavaScript?",
    },
  ],
});

console.log(completion.choices[0].message);

1
2
3
4
5
6
7
8
9
10
11
12
13
14from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-6-astra",
    reasoning_effort="low",
    messages=[
        {"role": "developer", "content": "Talk like a pirate."},
        {"role": "user", "content": "Are semicolons optional in JavaScript?"},
    ],
)

print(completion.choices[0].message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.DeveloperMessage("Talk like a pirate."),
			openai.UserMessage("Are semicolons optional in JavaScript?"),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

String semicolonsDevMsg = "Talk like a pirate.";

String semicolonsPrompt = "Are semicolons optional in JavaScript?";

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addDeveloperMessage(semicolonsDevMsg)
        .addUserMessage(semicolonsPrompt)
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15using OpenAI.Chat;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

ChatCompletion completion = await client.CompleteChatAsync(
    [
        new DeveloperChatMessage("Talk like a pirate."),
        new UserChatMessage("Are semicolons optional in JavaScript?"),
    ]
);

Console.WriteLine(completion.Content[0].Text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18require "openai"

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :developer,
      content: "Talk like a pirate."
    },
    {
      role: :user,
      content: "Are semicolons optional in JavaScript?"
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "messages": [
            {
                "role": "developer",
                "content": "Talk like a pirate."
            },
            {
                "role": "user",
                "content": "Are semicolons optional in JavaScript?"
            }
        ]
    }'

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 `user`.	Los mensajes `user` son instrucciones proporcionadas por un usuario final y tienen menor prioridad que los mensajes `developer`.	Los mensajes generados por el modelo tienen el rol `assistant`.

Una conversación de varios turnos puede constar de 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.

Control de versiones de prompts en código

Guarda los prompts de producción en el código de tu aplicación en lugar de crear objetos de prompt reutilizables. Administrar 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á retirando los objetos de prompt reutilizables de la API. La creación de prompts perderá protagonismo 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 trabajos de ingeniería de prompts:

Mantén los generadores de prompts en un módulo pequeño cerca de la funcionalidad que los utiliza.
Usa argumentos de función tipados o esquemas para 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.
Implementa los cambios en los prompts mediante tu sistema de despliegue y usa indicadores de funcionalidades o configuración cuando necesites lanzamientos por etapas.

Si tu integración ya llama a un prompt guardado mediante un ID o una versión de prompt, usa la guía de migración de objetos de prompt para trasladar ese prompt al código.

Formato de mensajes con Markdown y XML

Al escribir mensajes developer y user, puedes ayudar al modelo a entender los límites lógicos de tu prompt y de los datos de contexto mediante una combinación de formato Markdown y etiquetas XML.

Los encabezados y las listas de Markdown pueden servir para delimitar las distintas secciones de un prompt e indicar su jerarquía al modelo. También pueden facilitar la lectura de tus prompts durante el desarrollo. Las etiquetas XML pueden ayudar a delimitar dónde comienza y termina un fragmento de contenido, como un documento de apoyo que se usa como referencia. Los atributos XML también permiten definir metadatos sobre el contenido del prompt a los que puedes hacer referencia en tus instrucciones.

En general, un mensaje de desarrollador contiene las siguientes secciones, normalmente en este orden (aunque el contenido y el orden óptimos pueden variar según el modelo que uses):

Identidad: describe el propósito, el estilo de comunicación y los objetivos generales del asistente.
Instrucciones: orienta al modelo sobre cómo generar la respuesta que buscas. ¿Qué reglas debe seguir? ¿Qué debe hacer y qué no debe hacer nunca? Esta sección puede contener varias subsecciones relevantes para tu caso de uso, como la manera en que el modelo debe llamar a funciones personalizadas.
Ejemplos: proporciona ejemplos de posibles entradas junto con la salida que esperas del modelo.
Contexto: proporciona al modelo cualquier información adicional que pueda necesitar para generar una respuesta, como datos privados o de propiedad exclusiva que no formen parte de sus datos de entrenamiento, u otros datos que sepas que serán especialmente relevantes. Por lo general, conviene colocar este contenido cerca del final del prompt, ya que puedes incluir un contexto diferente para cada solicitud de generación.

A continuación se muestra un ejemplo de cómo usar Markdown y etiquetas XML para construir un mensaje developer con secciones diferenciadas y ejemplos de apoyo.

Un mensaje de desarrollador para generar código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24# Identity

You are coding assistant that helps enforce the use of snake case
variables in JavaScript code, and writing code that will run in
Internet Explorer version 6.

# Instructions

* When defining variables, use snake case names (e.g. my_variable)
  instead of camel case names (e.g. myVariable).
* To support old browsers, declare variables using the older
  "var" keyword.
* Do not give responses with Markdown formatting, just return
  the code as requested.

# Examples

<user_query>
How do I declare a string variable for a first name?
</user_query>

<assistant_response>
var first_name = "Anna";
</assistant_response>

Envía un prompt para generar código a través de la API

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13import fs from "fs/promises";
import OpenAI from "openai";
const client = new OpenAI();

const instructions = await fs.readFile("fixtures/prompt.txt", "utf-8");

const response = await client.responses.create({
  model: "gpt-6-astra",
  instructions,
  input: "How would I declare a variable for a last name?",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14from openai import OpenAI

client = OpenAI()

with open("prompt.txt", "r", encoding="utf-8") as f:
    instructions = f.read()

response = client.responses.create(
    model="gpt-6-astra",
    instructions=instructions,
    input="How would I declare a variable for a last name?",
)

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
32package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()

	instructions, err := os.ReadFile("prompt.txt")
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:        "gpt-6-astra",
		Instructions: openai.String(string(instructions)),
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("How would I declare a variable for a last name?"),
		},
	})
	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
17import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .instructions(
            "You are a coding assistant. Answer with concise JavaScript examples and use semicolons.")
        .input("How would I declare a variable for a last name?")
        .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
18using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

string instructions = await File.ReadAllTextAsync("prompt.txt");
CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions = instructions,
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("How would I declare a variable for a last name?")
);

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
instructions = File.read(File.join(__dir__, "prompt.txt"))
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: instructions,
  input: "How would I declare a variable for a last name?"
)

puts(response.output_text)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "instructions": "'"$(< prompt.txt)"'",
    "input": "How would I declare a variable for a last name?"
  }'

Reduce costos y latencia con el almacenamiento de prompts en caché

Al construir un mensaje, procura colocar el contenido que esperas reutilizar en tus solicitudes a la API al principio del prompt y entre los primeros parámetros de la API que envíes en el cuerpo JSON de la solicitud a Chat Completions o Responses. Esto te permite maximizar la reducción de costos y latencia que ofrece el almacenamiento de prompts en caché.

Aprendizaje con pocos ejemplos

El aprendizaje con pocos ejemplos te permite orientar un modelo de lenguaje grande hacia una nueva tarea mediante unos cuantos ejemplos de entrada y salida en el prompt, en lugar de realizar un ajuste fino del modelo. El modelo “capta” implícitamente el patrón de esos ejemplos y lo aplica a un prompt. Al proporcionar ejemplos, procura mostrar una variedad de entradas posibles con las salidas deseadas.

Por lo general, los ejemplos se incluyen como parte de un mensaje developer en la solicitud a la API. Aquí tienes un mensaje developer de muestra con ejemplos que enseñan al modelo a clasificar reseñas de atención al cliente como positivas o negativas.

# Identity

You are a helpful assistant that labels short product reviews as
Positive, Negative, or Neutral.

# Instructions

* Only output a single word in your response with no additional formatting
  or commentary.
* Your response should only be one of the words "Positive", "Negative", or
  "Neutral" depending on the sentiment of the product review you are given.

# Examples

<product_review id="example-1">
I absolutely love this headphones — sound quality is amazing!
</product_review>

<assistant_response id="example-1">
Positive
</assistant_response>

<product_review id="example-2">
Battery life is okay, but the ear pads feel cheap.
</product_review>

<assistant_response id="example-2">
Neutral
</assistant_response>

<product_review id="example-3">
Terrible customer service, I'll never buy from them again.
</product_review>

<assistant_response id="example-3">
Negative
</assistant_response>

Incluye información de contexto relevante

Suele ser útil incluir en el prompt información de contexto adicional que el modelo pueda usar para generar una respuesta. Estas son algunas razones habituales para hacerlo:

Dar al modelo acceso a datos de propiedad exclusiva o a cualquier otro dato que no forme parte del conjunto de datos con el que se entrenó.
Limitar la respuesta del modelo a un conjunto específico de recursos que hayas determinado que serán los más útiles.

La técnica de añadir contexto relevante a la solicitud de generación del modelo a veces se denomina generación aumentada por recuperación (RAG). Puedes añadir contexto al prompt de muchas maneras: por ejemplo, consultar una base de datos vectorial e incluir el texto obtenido en el prompt, o usar la herramienta de búsqueda de archivos integrada de OpenAI para generar contenido a partir de documentos cargados.

Planificar según la ventana de contexto

Los modelos solo pueden manejar una cantidad limitada de datos dentro del contexto que consideran durante una solicitud de generación. Este límite de memoria se denomina ventana de contexto y se mide en tokens (fragmentos de los datos que proporcionas, desde texto hasta imágenes).

Los modelos tienen ventanas de contexto de distintos tamaños, desde poco más de 100 000 tokens hasta un millón de tokens en los modelos GPT-4.1 más recientes. Consulta la documentación de los modelos para conocer el tamaño específico de la ventana de contexto de cada uno.

Diseño de prompts para los modelos actuales

Los modelos GPT como gpt-6-astra se benefician de instrucciones precisas que incluyan explícitamente en el prompt la lógica y los datos necesarios para completar la tarea. Para aprovechar al máximo el modelo más reciente, comienza con la guía actual de diseño de prompts.

GPT-6 Astra prompting guide

Aprovecha al máximo los prompts para el modelo más reciente con orientación actualizada, ejemplos prácticos y notas de migración.

Prácticas recomendadas de diseño de prompts para el modelo más reciente

Para obtener información completa y actualizada, consulta las prácticas recomendadas de diseño de prompts para el modelo más reciente. Los recordatorios prácticos que aparecen a continuación siguen siendo válidos.

GPT-6 Astra

ofrece buenos resultados tanto al crear interfaces desde cero como al contribuir a bases de código grandes y consolidadas. Para obtener los mejores resultados, recomendamos usar las siguientes bibliotecas:

Estilos / UI: Tailwind CSS, shadcn/ui, Radix Themes
Íconos: Lucide, Material Symbols, Heroicons
Animación: Motion

Aplicaciones web desde cero

GPT-5 puede generar el front-end de aplicaciones web a partir de un solo prompt, sin necesidad de ejemplos. Aquí tienes un prompt de muestra:

123456You are a world class web developer, capable of producing stunning, interactive, and innovative websites from scratch in a single prompt. You excel at delivering top-tier one-shot solutions.
Your process is simple and follows these steps:
Step 1: Create an evaluation rubric and refine it until you are fully confident.
Step 2: Consider every element that defines a world-class one-shot web app, then use that insight to create a &lt;ONE_SHOT_RUBRIC&gt; with 5–7 categories. Keep this rubric hidden—it's for internal use only.
Step 3: Apply the rubric to iterate on the optimal solution to the given prompt. If it doesn't meet the highest standard across all categories, refine and try again.
Step 4: Aim for simplicity while fully achieving the goal, and avoid external dependencies such as Next.js or React.

Integración con bases de código grandes

Para tareas de ingeniería de front-end en bases de código más grandes, hemos comprobado que incluir estas categorías de instrucciones en los prompts da los mejores resultados:

Principios: establece estándares de calidad visual, usa componentes modulares y reutilizables, y mantén la coherencia del diseño.
UI/UX: especifica la tipografía, los colores, el espaciado y la distribución, los estados de interacción (al pasar el cursor, sin contenido, durante la carga) y la accesibilidad.
Estructura: define la organización de archivos y carpetas para facilitar la integración.
Componentes: proporciona ejemplos de wrappers reutilizables y estrategias para separar las llamadas al backend.
Páginas: proporciona plantillas para diseños habituales.
Instrucciones para el agente: pide al modelo que confirme los supuestos de diseño, cree la estructura inicial de los proyectos, haga cumplir los estándares, integre APIs, pruebe los estados y documente el código.

Para obtener orientación detallada y ejemplos de prompts específicos para desarrollo de front-end, consulta las prácticas recomendadas de diseño de prompts para el modelo más reciente.

Para ejecuciones con agentes y de larga duración con gpt-6-astra, centra tus prompts en tres prácticas fundamentales: planificar las tareas a fondo para asegurar su resolución completa, proporcionar preámbulos claros para las decisiones importantes sobre el uso de herramientas y usar una herramienta TODO para llevar un seguimiento organizado del flujo de trabajo y del progreso.

Planificación y persistencia Indica al modelo que resuelva la consulta completa antes de ceder el control, que la divida en subtareas y que reflexione después de cada llamada a una herramienta para confirmar que no quede nada pendiente.

Remember, you are an agent - please keep going until the user's
query is completely resolved, before ending your turn and yielding
back to the user. Decompose the user's query into all required
sub-requests, and confirm that each is completed. Do not stop
after completing only part of the request. Only terminate your
turn when you are sure that the problem is solved. You must be
prepared to answer multiple queries and only finish the call once
the user has confirmed they're done.

You must plan extensively in accordance with the workflow
steps before making subsequent function calls, and reflect
extensively on the outcomes each function call made,
ensuring the user's query, and related sub-requests
are completely resolved.

Preámbulos para mayor transparencia

Pide al modelo que explique por qué llama a una herramienta, pero solo en los pasos importantes.

Before you call a tool explain why you are calling it

Seguimiento del progreso con rúbricas y listas de tareas pendientes

Usa una herramienta de listas de tareas pendientes o una rúbrica para asegurar una planificación estructurada y evitar que se omitan pasos.

Para obtener orientación detallada y ejemplos de prompts específicos para crear agentes, consulta las prácticas recomendadas de diseño de prompts para el modelo más reciente.

Diseño de prompts para modelos de razonamiento

Hay algunas diferencias que debes considerar al diseñar prompts para un modelo de razonamiento en comparación con un modelo GPT. En general, los modelos de razonamiento ofrecen mejores resultados en tareas con solo indicaciones generales. Esto difiere de los modelos GPT, que se benefician de instrucciones muy precisas.

Puedes entender la diferencia entre los modelos de razonamiento y los modelos GPT de la siguiente manera.

Un modelo de razonamiento es como un colega experimentado. Puedes darle un objetivo y confiar en que resolverá los detalles.
Un modelo GPT es como un colega con poca experiencia. Trabajará mejor si recibe instrucciones explícitas para generar un resultado específico.

Para obtener más información sobre las prácticas recomendadas al usar modelos de razonamiento, consulta esta guía.

Próximos pasos

Ahora que conoces los conceptos básicos de las entradas y salidas de texto, puedes continuar con alguno de estos recursos.

Crea un prompt en el Playground

Usa el Playground para desarrollar prompts y mejorarlos de forma iterativa.

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.

Otros recursos

Para encontrar más inspiración, visita el OpenAI Cookbook, que contiene código de ejemplo y enlaces a recursos de terceros, como:

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Recursos

API heredadas

Elige un modelo

Texto y código

Diseño de prompts

Razonamiento

Imágenes y video

Tiempo real y audio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Búsqueda y recuperación

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Contenido multimedia

GPT-Live

Realtime API

Desarrollar con voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos fundamentales

Plan

Build

Test and publish

Conversion specs

Guías

Recursos

Primeros pasos

Guías

File Upload

API

Measurement

Advertiser API

Referencia de la API

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las capacidades de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Extender y automatizar

Entornos

Crear con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Seguridad cibernética

Primeros pasos

ChatGPT Work

Identidad y autenticación

Acceso, políticas y modelos del espacio de trabajo

Controles de complementos y conectores

Uso, gobernanza y cumplimiento

Implementación y proveedores de modelos

Comunidad

Blog

Comunidad

Blog