Mejora tus resultados con estrategias de ingeniería de prompts.
Responses
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 en texto, como código, ecuaciones matemáticas, datos estructurados en JSON o prosa similar a la que escribiría una persona.
1
2
3
4
5
6
7
8
9
10require "openai"openai = OpenAI::Client.newresponse = 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, el arreglo contiene un solo resultado:
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 puedes dar por hecho que encontrarás el texto generado por el modelo en output[0].content[0].text.
Algunos de nuestros SDK oficiales incluyen la propiedad output_text en las respuestas del modelo. Esta propiedad reúne todo el texto generado por el modelo en una sola cadena y te permite acceder a él directamente.
Además de texto sin formato, puedes pedirle al modelo que devuelva datos estructurados en formato JSON. Esta función se llama resultados estructurados.
La propiedad choices de la respuesta contiene un arreglo con el contenido generado por el modelo. En este ejemplo sencillo, el arreglo contiene un solo resultado:
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, puedes pedirle al modelo que devuelva datos estructurados en formato JSON. Esta función se llama resultados estructurados.
Cómo elegir un modelo
Al generar contenido con la API, una decisión importante es qué modelo usar. En los ejemplos de código anteriores, se indica con el parámetro model. Consulta la lista completa de modelos disponibles. Al elegir un modelo para generar texto, considera los siguientes factores:
Los modelos de razonamiento generan una cadena de pensamiento interna para analizar el prompt de entrada. Se destacan por su capacidad para comprender tareas complejas y planificar en varios pasos. Por lo general, también son más lentos y costosos de usar que los modelos GPT.
Los modelos GPT son rápidos, económicos y muy inteligentes, y dan mejores resultados cuando reciben instrucciones más explícitas sobre cómo realizar las tareas.
Los modelos grandes y los pequeños (mini o nano) ofrecen distintas combinaciones de velocidad, costo e inteligencia. Los grandes comprenden mejor los prompts y resuelven problemas con mayor eficacia en distintos ámbitos. Los pequeños suelen ser más rápidos y económicos.
Si tienes dudas, gpt-6-astra es una buena opción predeterminada para generar texto de uso general y refinar tus prompts.
Ingeniería de prompts
La ingeniería de prompts consiste en redactar instrucciones eficaces para que un modelo genere de forma consistente contenido que cumpla tus requisitos.
Como el contenido que genera un modelo no es determinista, diseñar prompts para obtener el resultado que buscas tiene tanto de arte como de ciencia. Aun así, puedes aplicar técnicas y prácticas recomendadas para obtener buenos resultados de manera consistente.
Algunas técnicas de ingeniería de prompts, como usar roles de mensaje, funcionan con todos los modelos. Sin embargo, para obtener los mejores resultados, quizás debas redactar los prompts de manera distinta según el tipo de modelo, por ejemplo, si usas un modelo de razonamiento o un modelo GPT. Incluso dos versiones de modelos de una misma familia pueden producir resultados diferentes. Por eso, a medida que desarrolles aplicaciones más complejas, te recomendamos especialmente estas dos prácticas:
Configura tus aplicaciones en producción para que usen versiones específicas de los modelos (por ejemplo, gpt-4.1-2025-04-14) y mantengan un comportamiento consistente.
Crea pruebas y conjuntos de evaluaciones que midan cómo responde el modelo a tus prompts. Así podrás monitorear su desempeño a medida que refines los prompts o cuando cambies o actualices la versión del modelo.
Veamos algunas herramientas y técnicas que puedes usar 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. Puedes indicar el tono y los objetivos, y dar ejemplos de respuestas correctas. Las instrucciones que proporciones de esta manera tienen prioridad sobre el prompt del parámetro input.
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, el contexto no incluirá las instrucciones que hayas enviado mediante instructions en turnos anteriores.
Los mensajes developer contienen instrucciones de quien desarrolla la aplicación y tienen prioridad sobre los mensajes user.
Los mensajes user contienen instrucciones del 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 incluir varios mensajes de estos tipos, además de otros tipos de contenido que aporten tanto tú como el modelo. Consulta más información sobre cómo administrar el estado de la conversación.
Puedes pensar en los mensajes developer y user como en una función y sus argumentos en un lenguaje de programación.
Los mensajes developer establecen las reglas del sistema y la lógica de negocio, 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 el código
Guarda los prompts de producción en el código de tu aplicación en lugar de crear objetos de prompt reutilizables. Al administrar los prompts en el código, puedes usar entradas tipadas, revisiones de código, pruebas y tu proceso habitual de despliegue para cambiar el comportamiento del modelo.
OpenAI está retirando gradualmente los objetos de prompt reutilizables de la API. A partir del 3 de junio de 2026, se dará menos prioridad a la creación de prompts. Está previsto que v1/prompts deje de funcionar el 30 de noviembre de 2026. Consulta las fechas vigentes en la página de funciones en desuso.
Para nuevos trabajos de ingeniería de prompts:
Agrupa las funciones que construyen los prompts en un módulo pequeño, cerca del código de la funcionalidad que las usa.
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 e input directamente a la API de respuestas.
Agrega datos de prueba representativos, pruebas y comprobaciones de evaluación antes de cambiar los prompts de producción.
Distribuye los cambios en los prompts a través de tu sistema de despliegue. Usa indicadores de funcionalidad u opciones de configuración cuando necesites lanzar los cambios por etapas.
Al escribir mensajes developer y user, puedes combinar el formato Markdown con etiquetas XML para que el modelo distinga las partes del prompt y de los datos de contexto.
Los encabezados y las listas de Markdown ayudan a delimitar las secciones de un prompt y a comunicar su jerarquía al modelo. También pueden facilitar la lectura de los prompts durante el desarrollo. Las etiquetas XML permiten indicar dónde empieza y termina un contenido, como un documento de referencia. Con los atributos XML también puedes definir metadatos sobre el contenido del prompt y hacer referencia a ellos en tus instrucciones.
En general, un mensaje de desarrollador contiene las siguientes secciones en este orden, aunque el contenido y el orden más adecuados 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: indica cómo debe generar el modelo la respuesta que buscas. ¿Qué reglas debe seguir? ¿Qué debe hacer y qué debe evitar siempre? Puedes incluir tantas subsecciones como requiera tu caso de uso, por ejemplo, para indicar cómo debe llamar a funciones personalizadas.
Ejemplos: incluye ejemplos de posibles entradas junto con la salida que esperas del modelo en cada caso.
Contexto: proporciona la información adicional que el modelo 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 son especialmente relevantes. Por lo general, conviene colocar este contenido cerca del final del prompt, ya que el contexto puede variar de una solicitud de generación a otra.
El siguiente ejemplo usa Markdown y etiquetas XML para crear un mensaje developer con secciones bien delimitadas y ejemplos de apoyo.
Ejemplo de prompt
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# IdentityYou are coding assistant that helps enforce the use of snake casevariables in JavaScript code, and writing code that will run inInternet 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>
Solicitud a la API
Envía un prompt para generar código mediante la API
JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13import fs from"fs/promises";import OpenAI from"openai";constclient=newOpenAI();constinstructions=await fs.readFile("fixtures/prompt.txt", "utf-8");constresponse=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 OpenAIclient = 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
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 OPENAI001string 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.newinstructions = 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 los costos y la latencia con el almacenamiento en caché de prompts
Al crear 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 la API para completar chats o a la API de respuestas. Así podrás aprovechar al máximo la reducción de costos y latencia que ofrece el almacenamiento en caché de prompts.
Aprendizaje con pocos ejemplos
El aprendizaje con pocos ejemplos te permite orientar un modelo de lenguaje de gran tamaño hacia una tarea nueva mediante unos cuantos ejemplos de entradas y salidas en el prompt, en lugar de ajustar el modelo. El modelo deduce el patrón a partir de los ejemplos y lo aplica al prompt. Procura que los ejemplos cubran una variedad de entradas posibles e indica la salida deseada para cada una.
Por lo general, los ejemplos se incluyen en un mensaje developer de la solicitud a la API. El siguiente mensaje developer muestra cómo pedirle al modelo que clasifique reseñas, como las que valoran el servicio al cliente, y responda con una sola palabra.
# IdentidadEres un asistente que clasifica reseñas breves de productos con una de estas etiquetas: “Positive”, “Negative” o “Neutral”.# Instrucciones* Responde con una sola palabra, sin formato adicional ni comentarios.* Elige únicamente entre “Positive”, “Negative” y “Neutral” según la opinión que exprese la reseña del producto que recibas.# Ejemplos<product_review id="example-1">¡Me encantan estos audífonos! La calidad del sonido es increíble.</product_review><assistant_response id="example-1">Positive</assistant_response><product_review id="example-2">La duración de la batería es aceptable, pero las almohadillas se sienten de mala calidad.</product_review><assistant_response id="example-2">Neutral</assistant_response><product_review id="example-3">La atención al cliente fue pésima. Nunca volveré a comprarles.</product_review><assistant_response id="example-3">Negative</assistant_response>
Incluye información de contexto relevante
A menudo conviene incluir en el prompt información adicional que el modelo pueda usar al generar una respuesta. Estos son algunos motivos habituales para hacerlo:
Darle al modelo acceso a datos de propiedad exclusiva o a otros datos que no formen parte de su conjunto de entrenamiento.
Limitar la respuesta del modelo a un conjunto específico de recursos que hayas identificado como los más útiles.
La técnica de agregar contexto relevante a la solicitud de generación del modelo se conoce a veces como generación aumentada por recuperación (RAG). Puedes agregar contexto al prompt de distintas maneras. Por ejemplo, puedes consultar una base de datos vectorial e incluir el texto que obtengas en el prompt, o usar la herramienta de búsqueda de archivos integrada de OpenAI para generar contenido a partir de documentos que hayas cargado.
Planificación según la ventana de contexto
La cantidad de datos que un modelo puede tener en cuenta al procesar una solicitud de generación es limitada. Este límite de memoria se llama ventana de contexto y se mide en tokens (fragmentos de los datos que envías, desde texto hasta imágenes).
El tamaño de la ventana de contexto varía según el modelo. Va desde poco más de 100 000 tokens hasta un millón en los modelos GPT-4.1 más recientes. Consulta la documentación de los modelos para conocer el tamaño de la ventana de contexto de cada uno.
Cómo escribir prompts para los modelos actuales
Los modelos GPT como gpt-6-astra dan mejores resultados cuando el prompt contiene instrucciones precisas que explicitan la lógica y los datos necesarios para completar la tarea. Para aprovechar al máximo el modelo más reciente, empieza por la guía de prompts vigente.
Los prompts para tareas de programación con gpt-6-astra son más eficaces si sigues estas prácticas: define el rol del agente, exige un uso estructurado de las herramientas y muéstralo con ejemplos, pide pruebas exhaustivas para verificar que el código funcione correctamente y establece pautas de Markdown para que la salida tenga un formato claro.
Instrucciones explícitas sobre el rol y el flujo de trabajo
Asigna al modelo el rol de agente de ingeniería de software con responsabilidades bien definidas. Indica cómo usar herramientas como functions.run para tareas de programación y especifica cuándo evitar determinados modos. Por ejemplo, indica que solo debe usar la ejecución interactiva cuando sea necesario.
Pruebas y validación
Indica al modelo que compruebe los cambios mediante pruebas unitarias o comandos de Python y que valide los parches con cuidado, ya que herramientas como apply_patch pueden devolver “Done” incluso si la operación falla.
Ejemplos de uso de herramientas
Incluye ejemplos concretos de cómo ejecutar comandos con las funciones disponibles. Esto mejora la fiabilidad y ayuda al modelo a seguir los flujos de trabajo previstos.
Pautas de Markdown
Indica al modelo que genere Markdown legible y semánticamente correcto, que use código en línea, bloques de código delimitados, listas y tablas cuando corresponda, y que encierre las rutas de archivos y los nombres de funciones y clases entre acentos graves.
funciona bien tanto para crear interfaces desde cero como para contribuir a bases de código extensas y consolidadas. Para obtener los mejores resultados, te recomendamos usar las siguientes bibliotecas:
Estilos e interfaz de usuario: Tailwind CSS, shadcn/ui, Radix Themes
Íconos: Lucide, Material Symbols, Heroicons
Animación: Motion
Aplicaciones web desde cero
GPT-5 puede generar el frontend de una aplicación web a partir de un solo prompt, sin necesidad de ejemplos. Este es un ejemplo de prompt:
123456Eres especialista en desarrollo web de primer nivel. Puedes crear desde cero sitios web innovadores, interactivos y visualmente impactantes a partir de un solo prompt. Te destacas por entregar soluciones de excelente calidad en una sola respuesta.Tu proceso es sencillo y consta de estos pasos:Paso 1: crea una rúbrica de evaluación y refínala hasta que tengas plena confianza en ella.Paso 2: considera qué elementos distinguen a una aplicación web excepcional creada a partir de un solo prompt. Úsalos para crear una rúbrica <ONE_SHOT_RUBRIC> de 5 a 7 categorías. Mantén la rúbrica oculta, ya que es de uso exclusivamente interno.Paso 3: aplica la rúbrica para mejorar la solución al prompt. Si la solución no alcanza el nivel más alto en todas las categorías, ajústala y vuelve a intentarlo hasta obtener la mejor solución posible.Paso 4: busca la solución más sencilla que cumpla por completo el objetivo y evita dependencias externas como Next.js o React.
Integración con bases de código extensas
Al desarrollar interfaces en bases de código extensas, hemos observado que los prompts dan mejores resultados cuando incluyen estas categorías de instrucciones:
Principios: establece criterios 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, la disposición de los elementos, los estados de la interfaz (al pasar el cursor, sin contenido o durante la carga) y los requisitos de accesibilidad.
Estructura: define la organización de archivos y carpetas para facilitar la integración.
Componentes: proporciona ejemplos de componentes envolventes reutilizables y estrategias para separar las llamadas al backend.
Páginas: proporciona plantillas para los 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 las normas, integre las API, pruebe los distintos estados y documente el código.
Para las ejecuciones de agentes y las de larga duración con gpt-6-astra, centra los prompts en tres prácticas: planificar las tareas en detalle para resolverlas por completo, explicar de antemano las decisiones importantes sobre el uso de herramientas y usar una herramienta de tareas pendientes para llevar un registro ordenado del trabajo y su avance.
Planificación y persistencia
Indica al modelo que divida la solicitud en subtareas y que revise el resultado de cada llamada a una herramienta. Pídele que resuelva toda la solicitud antes de devolverle el control al usuario y que solo finalice la llamada cuando el usuario confirme que ha terminado.
Recuerda que eres un agente. Sigue trabajando hasta resolver por completo la solicitud del usuario antes de terminar tu turno y devolverle el control. Divide la solicitud en todas las subtareas necesarias y confirma que hayas completado cada una. No te detengas si solo has resuelto parte de la solicitud. Termina tu turno únicamente cuando tengas la certeza de haber resuelto el problema. Prepárate para responder varias consultas y finaliza la llamada solo cuando el usuario confirme que ha terminado.Antes de hacer más llamadas a funciones, planifica en detalle lo que harás de acuerdo con los pasos del flujo de trabajo. Después de cada llamada, analiza detenidamente el resultado para asegurarte de resolver por completo tanto la solicitud del usuario como todas las subtareas relacionadas.
Explicaciones previas para dar transparencia
Pide al modelo que explique por qué va a llamar a una herramienta, pero solo en los pasos importantes.
Antes de llamar a una herramienta, explica por qué vas a usarla.
Seguimiento del avance con rúbricas y listas de tareas pendientes
Usa una herramienta de listas de tareas pendientes o una rúbrica para que el modelo siga un plan estructurado y no omita pasos.
Cómo escribir prompts para modelos de razonamiento
Al escribir un prompt para un modelo de razonamiento, conviene tener en cuenta algunas diferencias con los modelos GPT. En general, los modelos de razonamiento dan mejores resultados cuando solo reciben indicaciones generales para la tarea. Los modelos GPT, en cambio, se benefician de instrucciones muy precisas.
Puedes pensar en la diferencia entre los modelos de razonamiento y los modelos GPT de esta manera:
Un modelo de razonamiento se parece a un colega con mucha experiencia. Puedes darle un objetivo y confiar en que resolverá los detalles.
Un modelo GPT se parece a un colega con menos experiencia. Obtendrás mejores resultados si le das instrucciones explícitas para producir 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 explorar estos recursos.
