Cliente asíncrono y rendimiento
En esta página
Actualizado el 3 de noviembre de 2026 según la página Límites de tasa de xAI y la referencia de la API de Images: los límites del modelo Imagine se cuentan como solicitudes por segundo (6 en el nivel de entrada, 100 en el más alto), no «30 por minuto»; un semáforo acota las solicitudes concurrentes, no el rendimiento; las imágenes se generan en JPEG por defecto; y los tiempos específicos de la versión anterior, que carecían de medición publicada, dan paso a un cálculo. Fuentes: Límites de tasa · API de Images.
Optimización del rendimiento con asíncrono
Cuando necesitas generar o editar muchas imágenes, las llamadas secuenciales se convierten en un cuello de botella. El cliente asíncrono de la API de xAI te permite ejecutar múltiples solicitudes en paralelo, reduciendo significativamente el tiempo total de procesamiento.
El cliente AsyncOpenAI
El modo asíncrono no hace que una generación individual sea más rápida: una solicitud de imagen única tarda exactamente lo mismo. Lo que elimina es la espera innecesaria entre solicitudes; mientras el servidor calcula la primera imagen, tu programa puede solicitar otras diez en lugar de quedarse bloqueado. Por eso la ganancia es nula para una imagen y dramática para cincuenta.
from openai import AsyncOpenAI
import asyncio
import os
async_client = AsyncOpenAI(
api_key=os.getenv("XAI_API_KEY"),
base_url="https://api.x.ai/v1"
)
async def generate_image(prompt):
"""Genera una imagen de forma asíncrona."""
response = await async_client.images.generate(
model="grok-imagine-image",
prompt=prompt,
extra_body={"resolution": "1k"},
)
return response.data[0].url
async def main():
url = await generate_image("Un faro sobre un acantilado, estilo acuarela")
print(url)
asyncio.run(main())
Solicitudes paralelas con asyncio.gather
asyncio.gather lanza todas las solicitudes y luego espera a que termine el conjunto. La duración total pasa a ser la de la más lenta, no la suma de todas; esa es toda la diferencia, y se aprecia con solo tres o cuatro imágenes.
async def generate_batch(prompts):
"""Genera imágenes para múltiples indicaciones en paralelo."""
tasks = [generate_image(prompt) for prompt in prompts]
results = await asyncio.gather(*tasks)
return results
async def main():
prompts = [
"Retrato de un ingeniero, estilo corporativo",
"Vista panorámica de una ciudad futurista",
"Diagrama isométrico de un centro de datos",
"Logotipo abstracto azul y plateado",
"Ilustración de un equipo en una reunión"
]
urls = await generate_batch(prompts)
for prompt, url in zip(prompts, urls):
print(f"{prompt[:40]}... → {url}")
asyncio.run(main())
Con cinco indicaciones, en lugar de esperar a que cada solicitud termine antes de lanzar la siguiente, las cinco imágenes se calculan al mismo tiempo: el tiempo total se aproxima al de la solicitud más lenta.
Control del paralelismo
Sin un límite, gather lo lanza todo a la vez; y cincuenta solicitudes concurrentes en un modelo limitado a 6 solicitudes por segundo en el nivel de entrada producen una avalancha de errores 429 que te cuesta más tiempo que la ejecución secuencial. El semáforo no es, por tanto, una precaución opcional: es lo que hace usable el paralelismo. Calíbralo según el límite de tasa del modelo, nunca según la capacidad de tu máquina.
async def generate_with_limit(prompts, max_concurrent=5):
"""Genera imágenes con un número máximo de solicitudes paralelas."""
semaphore = asyncio.Semaphore(max_concurrent)
async def limited_generate(prompt):
async with semaphore:
return await generate_image(prompt)
tasks = [limited_generate(prompt) for prompt in prompts]
return await asyncio.gather(*tasks)
Las hojas oficiales de grok-imagine-image y grok-imagine-image-2.0 indican 6 solicitudes por segundo en el nivel de entrada, un límite que crece con el nivel de tu equipo hasta 100. Nota: un semáforo acota las solicitudes concurrentes, no el rendimiento. Con max_concurrent=5, te mantienes por debajo de 6 solicitudes por segundo siempre que cada generación dure más de un segundo; si tus respuestas llegan más rápido, espacia también los envíos. Consulta los límites de tu equipo en la consola de xAI antes de aumentarlos.
Canalización asíncrona completa
Esta canalización encadena las tres operaciones que deben ir juntas: generar, descargar inmediatamente (las URL caducan) y aislar fallos. En un lote grande, este tercer punto marca la diferencia entre un incidente y una pérdida total.
import aiohttp
import aiofiles
async def download_image(session, url, filepath):
"""Descarga una imagen de forma asíncrona."""
async with session.get(url) as resp:
if resp.status == 200:
async with aiofiles.open(filepath, "wb") as f:
await f.write(await resp.read())
return filepath
return None
async def pipeline(prompts, output_dir="output"):
"""Canalización completa: generación + descarga."""
os.makedirs(output_dir, exist_ok=True)
# Paso 1: generar todas las imágenes en paralelo
urls = await generate_with_limit(prompts, max_concurrent=5)
# Paso 2: descargar todas las imágenes en paralelo
async with aiohttp.ClientSession() as session:
download_tasks = []
for i, url in enumerate(urls):
if url:
# JPEG por defecto (image/jpeg), salvo que la configuración de calidad produzca PNG
filepath = os.path.join(output_dir, f"image_{i:03d}.jpg")
download_tasks.append(download_image(session, url, filepath))
saved_files = await asyncio.gather(*download_tasks)
count = sum(1 for f in saved_files if f)
print(f"{count}/{len(prompts)} imágenes generadas y guardadas")
Comparación entre síncrono y asíncrono
La ganancia se calcula sobre el papel. Si una generación tarda T segundos, veinte imágenes solicitadas una tras otra tardan unos 20 × T. Con cinco solicitudes concurrentes, avanzan en oleadas de cinco: unos 4 × T, una ganancia cercana a cinco, el número de solicitudes concurrentes, siempre que te mantengas bajo el límite de rendimiento. Mide T en tu propia cuenta antes de prometer una fecha límite: las páginas de imágenes de xAI no ofrecen tiempos de generación, y estos varían según el modelo, la resolución y la carga.
Gestión de errores
El comportamiento por defecto de gather es brutal: una excepción en una tarea propaga el error y pierdes los resultados de las demás, incluidas aquellas por las que ya has pagado. return_exceptions=True cambia esto: cada tarea devuelve要么 su resultado o su excepción, y tú decides qué hacer con los fallos sin sacrificar los éxitos.
async def safe_generate(prompt):
"""Genera una imagen con gestión de errores."""
try:
return await generate_image(prompt)
except Exception as e:
print(f"Error para '{prompt[:30]}...' : {e}")
return None
Puntos clave
- El cliente
AsyncOpenAIpermite solicitudes paralelas medianteasyncio - Usa
asyncio.gatherpara lanzar múltiples generaciones simultáneamente - Limita la concurrencia con un semáforo para respetar los límites de tasa
- La ganancia se aproxima al número de solicitudes concurrentes, dentro del límite de rendimiento autorizado (6 solicitudes por segundo en el nivel de entrada)
- Gestiona los errores individualmente para evitar perder todo el lote