Combina la generación de imágenes con otras herramientas de la API
En esta página
- Combina la generación de imágenes con otras herramientas de la API
- Haz que un modelo de lenguaje escriba el prompt
- Ilustra un artículo de extremo a extremo
- Describe una imagen para regenerarla de forma diferente
- Procesa grandes volúmenes por lotes
- Publica directamente en el almacenamiento
- Qué mantiene una pipeline en pie
Actualización 2 de noviembre de 2026 — Modelos de imagen.
gpt-image-1, el modelo para el que se escribió originalmente este curso, se discontinuó el 23 de octubre de 2026.gpt-image-1.5,gpt-image-1-miniychatgpt-image-latestse retirarán el 1 de diciembre de 2026. Los ejemplos ahora utilizangpt-image-2.5-sunburst, que ofrece la mayor precisión para la edición;gpt-image-2.5-flarees más rápido para la generación estándar. Ambos modelos también admiten las configuraciones de calidadxhighymax. Los modelos GPT Image devuelven siempre las imágenes en base64: el parámetroresponse_formatde los modelos DALL·E anteriores no es compatible y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).
Combina la generación de imágenes con otras herramientas de la API
De forma aislada, la generación de imágenes es una herramienta artesanal: escribes un prompt y obtienes un archivo. Su verdadero poder surge cuando se convierte en un paso dentro de una cadena automatizada: un modelo de lenguaje que redacta el prompt, un análisis de visión que describe una imagen de referencia o un almacenamiento que publica el resultado. Esta lección te muestra cómo conectar estas piezas.
Haz que un modelo de lenguaje escriba el prompt
Tus usuarios o compañeros no escriben prompts visuales; escriben breves. «Necesito una imagen para un artículo sobre IA en sanidad, futurista pero humana» no contiene composición, iluminación ni paleta. En lugar de pedirles que aprendan el vocabulario de la lección anterior, inserta un modelo de lenguaje para encargarse de la traducción. Asígnale el rol de director de arte en el mensaje de sistema y exígele que produzca las capas específicas del prompt, con instrucciones estrictas de no outputar nada más. De lo contrario, recibirás una explicación educada que luego tendrías que enviar a GPT Image.
from openai import OpenAI
import base64
client = OpenAI()
def text_to_image(brief: str, output: str):
"""
Pipeline de dos pasos:
1. Un LLM genera el prompt visual óptimo
2. GPT Image crea la imagen
"""
# Paso 1: Generar el prompt visual con un LLM
completion = client.chat.completions.create(
model="gpt-5.6-luna",
messages=[
{
"role": "system",
"content": (
"Eres un director de arte experto. "
"Basándote en un brief, genera un prompt detallado para un "
"modelo de generación de imágenes. Incluye: sujeto, composición, iluminación, "
"estilo, perspectiva, paleta de colores. "
"Responde solo con el prompt, sin explicaciones."
)
},
{"role": "user", "content": brief}
]
)
visual_prompt = completion.choices[0].message.content
print(f"Prompt generado: {visual_prompt[:100]}...")
# Paso 2: Generar la imagen
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=visual_prompt,
size="1536x1024",
quality="high",
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
print(f"Imagen generada: {output}")
return visual_prompt
prompt = text_to_image(
"Necesito una imagen para un artículo sobre inteligencia artificial "
"en sanidad. Futurista pero humana.",
"ai_health.png"
)
Ilustra un artículo de extremo a extremo
Un artículo de fondo necesita una imagen de portada y una ilustración por sección. Estas imágenes deben parecer cohesivas sin ser idénticas. La función illustrate_article aplica esta lógica reinyectando el estilo en cada prompt y repitiendo el título del artículo cada vez, lo que otorga unidad temática al conjunto completo. Dos detalles para ahorrar costes merecen atención: la portada se genera con calidad high porque todo el mundo la ve y a menudo se comparte, mientras que las ilustraciones de sección se mantienen en medium ya que se muestran más pequeñas y abajo en la página. Para las cinco secciones de este ejemplo sobre IA en reclutamiento, este compromiso reduce la factura sin que el lector note nada.
from openai import OpenAI
import base64
import json
client = OpenAI()
def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
"""
Genera una ilustración de cabecera + una por sección.
"""
results = []
# Imagen de portada
header_prompt = (
f"Imagen de portada para un artículo titulado \"{title}\", "
f"estilo {style}, composición panorámica, "
"sin texto en la imagen, profesional"
)
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=header_prompt,
size="1536x1024",
quality="high",
)
path = f"{output_dir}/header.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
results.append({"type": "header", "path": path})
print(f"Cabecera: {path}")
# Ilustraciones de sección
for i, section in enumerate(sections):
section_prompt = (
f"Ilustración para la sección \"{section}\" "
f"de un artículo sobre \"{title}\", "
f"estilo {style}, formato rectangular, "
"ilustración conceptual sin texto"
)
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=section_prompt,
size="1536x1024",
quality="medium",
)
path = f"{output_dir}/section_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
results.append({"type": f"section_{i+1}", "section": section, "path": path})
print(f"Sección {i+1} ({section[:30]}...) : {path}")
return results
illustrate_article(
title="5 formas en que la IA está transformando el reclutamiento",
sections=[
"Cribado automático de CV",
"Entrevistas en vídeo analizadas por IA",
"Emparejamiento inteligente candidato-puesto",
"Reducción del sesgo en el reclutamiento",
"Incorporación personalizada",
],
style="Ilustración isométrica 3D, tonos azules y violetas",
output_dir="."
)
Describe una imagen para regenerarla de forma diferente
¿Cómo consigues una versión invernal de un paisaje de verano cuando solo tienes el archivo, sin máscara y sin herramientas de edición? Pasa por el lenguaje. La visión del modelo analiza la imagen y produce una descripción lo suficientemente precisa para servir como prompt de reconstrucción: sujeto, composición, iluminación, colores, estilo, perspectiva, estado de ánimo. Luego concatenas tu instrucción de modificación a esta descripción. El modelo de generación recibe un prompt de texto completo donde solo ha cambiado la estación, y obtienes una imagen coherente con la original en lugar de algo unrelated. Esta es también la forma más fiable de reproducir la identidad visual de una imagen de referencia que no puedes editar directamente.
from openai import OpenAI
import base64
client = OpenAI()
def analyze_and_vary(image_path: str, instruction: str, output: str):
"""
1. Analiza una imagen con GPT Vision
2. Genera una variante basada en el análisis
"""
# Paso 1: Analizar la imagen
with open(image_path, "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
analysis = client.chat.completions.create(
model="gpt-5.6-luna",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": (
"Describe esta imagen en detalle para que un modelo "
"de generación de imágenes pueda reproducirla fielmente. "
"Incluye: sujeto, composición, iluminación, colores, estilo, "
"perspectiva, estado de ánimo. Sé muy preciso."
)
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
}
]
)
description = analysis.choices[0].message.content
print(f"Análisis: {description[:150]}...")
# Paso 2: Generar una variante modificada
variant_prompt = f"{description}. Modificación solicitada: {instruction}"
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=variant_prompt,
size="1024x1024",
quality="high",
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
print(f"Variante generada: {output}")
analyze_and_vary(
"original_landscape.png",
"Cambia la estación de verano a invierno, con nieve en los tejados y los árboles",
"winter_landscape.png"
)
Procesa grandes volúmenes por lotes
Generar cinco visuales de producto en serie lleva minutos; generar quinientos secuencialmente lleva toda la noche y falla ante el primer tropiezo de red. La configuración siguiente resuelve ambos problemas. Cada tarea es un diccionario autónomo que lleva su ID, prompt, archivo de salida y configuración. La función worker envuelve la llamada en un bloque try que devuelve un estado en lugar de colapsar todo el lote: una generación rechazada no tumba a las otras cuatrocientas noventa y nueve. El ThreadPoolExecutor paraleliza entonces la ejecución, pero con un max_workers deliberadamente bajo —tres en este ejemplo— porque el cuello de botella no es tu máquina, son las cuotas de la API. El informe final cuenta éxitos y fallos para que sepas qué reintentar.
from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
client = OpenAI()
def generate_one_image(task: dict) -> dict:
"""Genera una única imagen a partir de una tarea."""
try:
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=task["prompt"],
size=task.get("size", "1024x1024"),
quality=task.get("quality", "medium"),
)
data = base64.b64decode(response.data[0].b64_json)
with open(task["output"], "wb") as f:
f.write(data)
return {"id": task["id"], "status": "ok", "path": task["output"]}
except Exception as e:
return {"id": task["id"], "status": "error", "error": str(e)}
def batch_generation(tasks: list[dict], max_parallel: int = 3):
"""Ejecuta un lote de generaciones con paralelismo controlado."""
results = []
with ThreadPoolExecutor(max_workers=max_parallel) as executor:
futures = {
executor.submit(generate_one_image, task): task
for task in tasks
}
for future in as_completed(futures):
result = future.result()
results.append(result)
status = result["status"]
print(f" [{status}] {result['id']}")
# Informe
ok = sum(1 for r in results if r["status"] == "ok")
errors = sum(1 for r in results if r["status"] == "error")
print(f"\nFinalizado: {ok} ok, {errors} errores de {len(tasks)} tareas")
return results
# Define un lote de tareas
tasks = [
{
"id": f"product_{i}",
"prompt": f"Foto de producto e-commerce: {product}, fondo blanco, estudio",
"output": f"batch_product_{i}.png",
"quality": "high"
}
for i, product in enumerate([
"reloj de oro rosa",
"gafas de sol de aviador",
"pulsera de cuero trenzado",
"anillo de solitario con diamante",
"collar de perlas cultivadas",
])
]
results = batch_generation(tasks, max_parallel=3)
Publica directamente en el almacenamiento
Escribir el PNG en el disco de la máquina que ejecuta el script solo tiene sentido en desarrollo. En producción, la imagen debe aterrizar donde tu sitio la vaya a buscar, y hacer un desvío por el sistema de archivos local se convierte en un punto de fallo innecesario. El formato b64_json se adapta bien a esta eliminación: los bytes decodificados se envuelven en un objeto BytesIO y se empujan directamente al bucket, con un ContentType explícito —sin el cual los navegadores ofrecerían una descarga en lugar de mostrar la imagen—. La función devuelve la URL pública, que es lo que tu CMS necesita realmente.
from openai import OpenAI
import base64
import boto3
from io import BytesIO
client = OpenAI()
def generate_and_store_s3(prompt: str, bucket: str, key: str):
"""Genera una imagen y la sube directamente a S3."""
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="high",
)
image_data = base64.b64decode(response.data[0].b64_json)
s3 = boto3.client("s3")
s3.upload_fileobj(
BytesIO(image_data),
bucket,
key,
ExtraArgs={"ContentType": "image/png"}
)
url = f"https://{bucket}.s3.amazonaws.com/{key}"
print(f"Imagen almacenada en S3: {url}")
return url
# Ejemplo
url = generate_and_store_s3(
"Icono de aplicación móvil: libro abierto con estrellas, diseño plano",
"my-image-bucket",
"generated/app_icon_v1.png"
)
Qué mantiene una pipeline en pie
Las cinco pipelines de esta lección comparten la misma higiene de construcción. Cada paso hace una cosa, lo que te permite reemplazar la escritura del prompt o el almacenamiento sin tocar el resto. Cada paso gestiona sus propios errores; de lo contrario, un rechazo de moderación en medio de un lote tumba toda la cadena: eso es exactamente lo que previene el try en generate_one_image. El paralelismo se mantiene estrangulado para respetar los límites de tasa, y en este punto, la precaución cuesta menos que la recuperación tras una prohibición temporal.
Quedan dos hábitos menos visibles pero igual de decisivos. Registra los prompts realmente enviados, especialmente cuando los escribe un modelo de lenguaje: sin este registro, una imagen que te encanta se vuelve irreproducible en la segunda ejecución. Y almacena en caché los resultados siempre que el mismo prompt pueda volver, algo que la siguiente lección formaliza en un sistema completo.
Ahora ensambla tu propia cadena completa: toma un título de artículo como entrada, pide a un modelo de lenguaje tres descripciones de visuales relevantes, genera las tres imágenes en paralelo y produce un JSON resumen que enlace cada prompt con su archivo. Tendrás entonces todo lo necesario para ilustrar un blog entero sin intervención manual.