Paralelismo y concurrencia
En esta página
Esperar juntos no es computar juntos
Una llamada a la API de OpenAI es una operación limitada por E/S: tu programa no está procesando números, está esperando una respuesta de red. Esta naturaleza dicta la herramienta adecuada. El paralelismo, en el sentido de multiproceso, distribuye el cómputo entre varios núcleos; cuesta un proceso completo por unidad de trabajo, y ejecutar cien procesos que están todos esperando a la red es un desperdicio absoluto. La concurrencia, tal como la proporciona asyncio, permite que un único proceso gestione cientos de esperas simultáneas con un coste insignificante. Esto es lo que maximiza tu rendimiento de llamadas.
La distinción es más que académica: un equipo que paraleliza sus llamadas al LLM con un pool de procesos consumirá varios gigabytes de memoria para obtener cero ventajas frente a unas pocas líneas de asyncio.
Lanzamiento de llamadas concurrentes
El SDK expone un cliente asíncrono, AsyncOpenAI, cuyas llamadas se esperan con await. Agrupar múltiples corrutinas en un asyncio.gather permite que todas progresen simultáneamente, haciendo que la duración total se aproxime a la de la llamada más lenta en lugar de a la suma de todas.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Una única llamada asíncrona a la API."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Lanza todas las llamadas de forma concurrente."""
tasks = [single_call(prompt) for prompt in prompts]
results = await asyncio.gather(*tasks, return_exceptions=True)
for i, result in enumerate(results):
if isinstance(result, Exception):
print(f"Error en el prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
La bandera return_exceptions=True es lo que distingue un prototipo de un procesamiento de grado productivo. Sin ella, la primera excepción interrumpe el gather y pierdes los noventa y nueve resultados ya obtenidos. Con ella, los errores se convierten en valores que inspeccionas, registras y reintentas a tu propio ritmo.
Sin embargo, esta versión cruda tiene un fallo inmediato: lanzar mil llamadas de golpe superará tus límites de tasa en segundos. Un semáforo resuelve esto permitiendo solo un número fijo de llamadas simultáneas, mientras el resto espera pacientemente su turno. Veinte es un punto de partida razonable, que deberás ajustar según las cuotas reales de tu organización.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Limita el número de llamadas simultáneas."""
semaphore = asyncio.Semaphore(max_concurrency)
async def limited_call(prompt: str) -> str:
async with semaphore:
return await single_call(prompt)
tasks = [limited_call(prompt) for prompt in prompts]
return await asyncio.gather(*tasks, return_exceptions=True)
El patrón Map-Reduce aplicado al texto
Un documento de doscientas páginas no puede resumirse en una única llamada, y dividirlo secuencialmente llevaría minutos. El patrón map-reduce se aplica aquí de forma natural: divide en fragmentos, resume cada fragmento concurrentemente y luego pide al modelo una síntesis de los resúmenes. La fase de map se beneficia plenamente de la concurrencia, mientras que la fase de reduce es una única llamada sobre un texto que se ha vuelto corto.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Resume un documento largo mediante map-reduce paralelo."""
# Fase MAP: dividir y resumir en paralelo
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Resume este pasaje en 3 puntos clave:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Fase REDUCE: combinar resúmenes
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Sintetiza estos resúmenes parciales en un resumen coherente "
f"de 5 puntos clave:\n\n{summary_text}"
)
return final_summary
El filtrado if isinstance(r, str) es tanto una decisión de producto como una precaución técnica: significa que la síntesis final se producirá incluso si tres fragmentos han fallado en silencio. Dependiendo del contexto, esto es exactamente lo que quieres, o es inaceptable. Decídelo explícitamente y, en cualquier caso, registra el número de fragmentos perdidos.
Cuándo vuelve a ser relevante el multiproceso
Siguen existiendo situaciones raras donde el cómputo retoma el control: postprocesamiento pesado sobre respuestas, extracción de entidades, puntuación, análisis estructurado. Este trabajo está limitado por la CPU y no gana nada con asyncio. La combinación elegante es encadenar los dos regímenes en una única tubería: llamadas de red en concurrencia y luego cómputo distribuido a través de un pool de procesos mediante run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Procesamiento limitado por CPU sobre el resultado (NLP, análisis, etc.)."""
# Ejemplo: extracción de entidades, puntuación, etc.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Tubería: llamadas asíncronas al LLM + postprocesamiento paralelo en CPU."""
# Paso 1: llamadas concurrentes al LLM
llm_results = await calls_with_limit(prompts)
# Paso 2: postprocesamiento paralelo (CPU)
loop = asyncio.get_event_loop()
with ProcessPoolExecutor(max_workers=4) as pool:
tasks = [
loop.run_in_executor(pool, heavy_post_processing, r)
for r in llm_results
if isinstance(r, str)
]
final_results = await asyncio.gather(*tasks)
return final_results
Verifica que el cómputo justifique realmente el pool antes de introducirlo: serializar datos hacia otro proceso tiene un coste, y para tratamientos que duran unos pocos milisegundos este coste supera la ganancia.
Verificación del rendimiento real
Ajustar max_concurrency no es cuestión de adivinar. Si es demasiado bajo, dejarás rendimiento sobre la mesa; si es demasiado alto, activarás límites de tasa que te costarán más tiempo del que ahorran. Mide con tu carga real, variando el valor, y observa tanto el rendimiento como el recuento de éxitos: una tubería muy rápida que falla una de cada cinco veces no es rápida.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Mide el rendimiento real de tu tubería."""
prompts = [
f"Da un dato interesante número {i}."
for i in range(num_requests)
]
start = time.perf_counter()
results = await calls_with_limit(prompts, max_concurrency=20)
duration = time.perf_counter() - start
successes = sum(1 for r in results if isinstance(r, str))
print(f"Solicitudes: {num_requests}")
print(f"Aciertos: {successes}")
print(f"Duración: {duration:.1f}s")
print(f"Rendimiento: {successes / duration:.1f} req/s")
Puntos clave
- Usa
AsyncOpenAIyasyncio.gatherpara la concurrencia de E/S - Limita la concurrencia con un semáforo para respetar las cuotas
- El patrón map-reduce paraleliza el procesamiento de documentos largos
- Reserva
ProcessPoolExecutorpara el postprocesamiento intensivo en CPU