Ir al contenido principal
Español— Elegir un idioma
Menú

Optimización de extremo a extremo: del prompt a la red

Lección 2 de 20 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. La optimización es un sistema, no un parámetro
  2. Optimiza el prompt
  3. Optimiza los parámetros de la API
  4. Optimiza la red
  5. Optimiza el posprocesamiento
  6. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API de Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

La optimización es un sistema, no un parámetro

Reducir la latencia y los costes de una aplicación con LLM no consiste solo en elegir un modelo más rápido. Se trata de una cadena de optimizaciones que va desde el prompt hasta la configuración de red, donde el eslabón más débil determina el rendimiento del conjunto. Un equipo que reduzca a la mitad el tamaño de su prompt de sistema pero deje que su servidor abra una nueva conexión TLS para cada solicitud perderá en sobrecarga de red lo ahorrado en tokens.

El orden en que abordes estas palancas importa. Empieza por el prompt, ya que afecta tanto al coste como a la latencia sin requerir cambios en la infraestructura. A continuación, ajusta los parámetros de la API, luego la configuración de red y, finalmente, la forma en que tu aplicación consume la respuesta. Esta lección te guía por cada palanca en ese orden.

Optimiza el prompt

Cada token de entrada cuesta tiempo y dinero, y la mayoría de los prompts en producción arrastran bagaje de su fase de prototipado: instrucciones añadidas una a una, cada una reformulando la anterior. Tu primer reflejo debe ser reescribir el prompt de forma densa, eliminando fórmulas de cortesía y repeticiones sin tocar las restricciones reales que se transmiten al modelo.

# ❌ Prompt verboso
prompt_long = """
Eres un asistente experto en análisis financiero. Debes responder
siempre de manera profesional y estructurada. Debes usar datos
numéricos cuando sea posible. Debes evitar jerga innecesaria.
Debes ser conciso pero completo.
Analiza el siguiente informe trimestral: ...
"""

# ✅ Prompt optimizado (mismo resultado, menos tokens)
prompt_court = """Rol: Analista financiero senior.
Restricciones: Estructurado, numérico, conciso.
Tarea: Analiza este informe trimestral: ..."""

Ambas versiones transmiten exactamente las mismas cinco restricciones; la segunda lo hace sin las cinco frases «Debes» que no aportan nada al modelo. En un servicio que procesa diez mil informes al día, esta reescritura de treinta segundos se paga sola diariamente.

Elige el modelo adecuado para la tarea

La segunda palanca se basa en que no todas las llamadas requieren el mismo modelo. Enrutar una tarea de extracción de campos a un modelo de alto razonamiento implica pagar por capacidad que la tarea no usa y esperar más tiempo por un resultado idéntico.

Tipo de tareaModelo recomendadoMotivo
Clasificación / extraccióngpt-5.6-lunaRápido, económico
Razonamiento complejogpt-5.6-terra con razonamiento mediumMejor relación calidad/coste
Tareas críticasgpt-5.6-sol con razonamiento highMáxima calidad, más lento
Alto volumengpt-5.6-luna vía Batch API-50 % de coste

En la práctica, codifica esta elección en una función de enrutamiento en lugar de dejarla al criterio de los desarrolladores; de lo contrario, el modelo por defecto siempre acabará imponiéndose:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Selecciona el modelo óptimo según la tarea."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

Optimiza los parámetros de la API

Una respuesta demasiado larga desperdicia tiempo de generación que nadie va a leer. Especifica siempre max_output_tokens: este es un límite estricto que protege tanto tu factura como tu interfaz, evitando que un prompt mal formulado derive en una digresión de dos mil palabras.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature requiere effort none
    input="Resume este texto en una frase.",
    max_output_tokens=100,  # Límite estricto
    temperature=0.0,         # Determinista = más rápido
)

Los parámetros de muestreo funcionan en la misma dirección. Establecer temperature=0 hace que las respuestas sean deterministas y ligeramente más rápidas, que es exactamente lo que buscas en tareas de extracción o clasificación donde la creatividad es fuente de varianza, no un activo. Reducir top_p a 0,1 restringe el espacio de búsqueda y acelera la generación; reserva este ajuste para tareas donde solo se acepta una formulación concreta, y mantén los valores por defecto donde la riqueza de la respuesta forma parte del producto.

Optimiza la red

El coste del viaje de los paquetes se acumula en cada llamada, aunque permanece invisible en las métricas de tu aplicación. La API de OpenAI se aloja principalmente en la costa este de EE. UU.: colocar tu servidor de aplicación en la misma región que el endpoint puede suponer una ganancia potencial de 50 a 150 milisegundos en latencia de red. Para una aplicación conversacional, esto representa una fracción significativa del Tiempo hasta el Primer Token (TTFT).

La segunda ganancia proviene de la reutilización de conexiones. Sin un pool, cada solicitud repite el handshake TLS, añadiendo varios viajes de ida y vuelta antes de que fluya cualquier dato útil. Configurar un cliente HTTP una sola vez soluciona esto:

import httpx

# Cliente con pool de conexiones persistentes
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimiza el posprocesamiento

El último eslabón suele ser el que la gente olvida: una aplicación que recibe una respuesta en streaming pero espera hasta el final para mostrarla anula todos los beneficios del streaming. Procesa la respuesta sobre la marcha en lugar de hacerlo tras la recepción completa.

async def progressive_processing(prompt: str):
    """Procesa cada fragmento tan pronto como llega."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Procesar por frase completa
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Dividir por frases completas es un compromiso deliberado: emitir cada token produce una visualización entrecortada, mientras que esperar a todo el párrafo recrea la sensación de espera. La frase es la unidad que los lectores consumen de forma natural. Reutiliza este patrón siempre que tu interfaz necesite mostrar, leer en voz alta o transmitir en streaming lo que produce el modelo.

Puntos clave

  • Optimiza primero el prompt: menos tokens = menos latencia y coste
  • Enruta al modelo adecuado según la complejidad de la tarea
  • Limita max_output_tokens y usa temperature=0 cuando sea posible
  • Reutiliza las conexiones HTTP y procesa las respuestas mediante streaming