programa
Associate AI Engineer para desarrolladores
26 h
Trabajar con la API de OpenAI
Comienza tu viaje desarrollando aplicaciones potenciadas por IA con la API OpenAI.
¿Qué es la API de GPT-6 Astra?
La API de GPT-6 Astra es la forma de acceder al nuevo modelo insignia de OpenAI, lanzado el 3 de septiembre de 2026, a través de la Responses API. Para este tutorial, lo importante es la superficie: gpt-6-astra acepta texto e imágenes a través de la Responses API de OpenAI. Su esfuerzo de razonamiento va de low a max, sin opción none.
Los ejemplos de este tutorial usan client.responses.create en lugar de client.chat.completions.create, pero migrar también exige cambios en los formatos de petición, salida y resultados de herramientas. Elimina los ajustes personalizados de temperature, top_p y probabilidades logarítmicas, ya que Astra no los admite. Antes de la primera llamada, veamos los precios.
¿Cuánto cuesta GPT-6 Astra?
Para peticiones con hasta 272.000 tokens de entrada, la tarifa estándar es de 10 $ por cada millón de tokens de entrada ordinarios y 50 $ por cada millón de tokens de salida. La entrada en caché cuesta 1 $ por millón, y las escrituras en caché 12,50 $ por millón.
Si una petición supera ese umbral, OpenAI aplica un multiplicador de 2x a las tarifas de entrada y caché, y de 1,5x a la tarifa de salida. Las tarifas más altas se aplican a toda la petición, no solo a los tokens que exceden el umbral. Ninguna de las ejecuciones de este tutorial se acercó al umbral.
¿Qué vamos a construir con la API de GPT-6 Astra?
La app de staging es un pequeño panel de tareas en Flask: una página de inicio, un formulario para añadir tareas, un botón para marcarlas como hechas y un endpoint /health . El código completo, incluida la app de staging, está en este repositorio de GitHub.
Tres tareas precargadas aparecen antes de las pruebas. Imagen del autor.
La app tiene un fallo intencional. El agente ejecuta tres comprobaciones, pero solo la suite de tests está diseñada para detectarlo.
¿Por qué la app acepta títulos de tareas en blanco?
El endpoint de creación de tareas no rechaza un título vacío. Dejé ese comportamiento para que el agente tenga un fallo conocido que encontrar sin desvelarlo en el prompt.
¿Qué comprobaciones de release puede ejecutar el agente?
El agente puede llamar a tres herramientas:
-
run_test_suiteejecuta pytest, con una prueba de importación masiva de unas 250 peticiones HTTP. -
check_ui_flowusa Playwright para añadir una tarea y confirmar que aparece. -
check_staging_healthenvía una petición GET a/health.
Las tres corren contra staging, sin mocks. La comprobación de navegador usa código fijo; la demo de uso del ordenador redactada por el modelo viene después.
Cómo configurar la API de GPT-6 Astra en Python
Necesitas una clave de la API de OpenAI con acceso a gpt-6-astra. Crea una clave en platform.openai.com/api-keys y comprueba que tu proyecto tiene gpt-6-astra activado. En los espacios Enterprise, Astra está desactivado por defecto en el lanzamiento.
Los comandos siguientes usan Windows PowerShell e instalan todos los paquetes necesarios para este tutorial, incluido realtime de OpenAI para la demo de steering.
python -m venv .venv
.venv\Scripts\Activate.ps1
Copy-Item .env.example .env
pip install "openai[realtime]" flask pytest playwright pydantic matplotlib python-dotenv streamlit
playwright install chromiumEn macOS o Linux, sustituye el comando de activación por source .venv/bin/activate y el de copia por cp .env.example .env.
Luego añade la clave de API al nuevo archivo .env: abre el fichero .env que acabas de copiar y añade OPENAI_API_KEY=sk-..., que python-dotenv carga y el SDK recoge automáticamente, así que no pasas la clave en el código.
Si los archivos .env o las dependencias por proyecto te suenan nuevos, nuestros tutoriales de entornos virtuales y variables de entorno lo explican. Comprueba que la clave funciona antes de seguir.
Si tu clave ya funciona con la Responses API, salta la siguiente subsección y empieza con el bucle sincrónico de herramientas. La primera petición solo verifica la configuración.
Haz tu primera llamada a la API de GPT-6 Astra
Una vez tengas la clave, hay que cargarla con dotenv. Después puedes crear un cliente de OpenAI y enviar tu primera petición con client.responses.create(). La petición más pequeña posible se ve así:
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv()
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
input="In one sentence, what is a staging environment used for?",
)
print(response.output_text)El campo usage de la respuesta lista los recuentos de tokens necesarios para el cálculo de costes posterior.
Crea un bucle sincrónico de herramientas con GPT-6 Astra
Los fragmentos de abajo son extractos; las versiones ejecutables están en el repositorio de GitHub asociado.
Antes de tocar nada asíncrono, construí la versión normal:
-
Llamar al modelo
-
Buscar un elemento
function_call -
Ejecutar la herramienta correspondiente
-
Enviar el resultado de vuelta con
previous_response_id -
Repetir hasta que el modelo deje de pedir herramientas.
Este bucle bloqueante es la base para la comparación async.
for turn in range(max_turns):
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
tools=TOOLS,
input=next_input,
previous_response_id=previous_response_id,
)
calls = [item for item in response.output if item.type == "function_call"]
if not calls:
final_text = response.output_text
break
outputs = [
{"type": "function_call_output", "call_id": call.call_id, "output": run_tool(call)}
for call in calls
]
next_input, previous_response_id = outputs, response.idQué encontró la ejecución base
En la ejecución base, el modelo llamó a cada herramienta por turno. Encontró el fallo de validación conocido y devolvió una decisión de no continuar. En tres ejecuciones, el tiempo medio de muro fue de 23,40 segundos. Ese promedio cubre la ejecución completa, no los tiempos de cada herramienta.
¿Cómo funciona el uso asíncrono de herramientas en GPT-6 Astra?
Marca una herramienta con "async": true en su esquema, y tu app podrá aplazar ese resultado mientras el modelo sigue trabajando o espera. Tu aplicación sigue ejecutando la herramienta y gestionando el trabajo en segundo plano.
Cómo ejecutar comprobaciones independientes en paralelo
Marqué run_test_suite y check_ui_flow como async, y añadí una herramienta wait_for_tasks definida por la app y sin argumentos, ya que esta demo solo tiene un lote de trabajo pendiente a la vez. Esa espera sin argumentos mantiene el ejemplo pequeño.
En un runner de producción, identifica los trabajos con manejadores de tarea, vincula cada manejador a su call_id original, y espera solo cuando el siguiente paso dependa de un resultado pendiente.
Devuelve cada resultado completado en su call_id original, y luego devuelve el estado de espera en el propio call_id de la herramienta de espera.
TOOLS = [
{"type": "function", "name": "run_test_suite", "async": True, ...},
{"type": "function", "name": "check_ui_flow", "async": True, ...},
{"type": "function", "name": "check_staging_health", ...},
{"type": "function", "name": "wait_for_tasks", ...},
]Para esta ejecución, la app envió cada llamada marcada a un pool de hilos. Mientras corrían las comprobaciones en segundo plano, realizó la comprobación de salud sincrónica rápida. Luego se bloqueó en wait_for_tasks hasta que las comprobaciones pendientes terminaron.
¿Reduce el tiempo total el uso asíncrono?
En tres ejecuciones, async redujo el tiempo medio de 23,40 a 18,94 segundos (−19,1%). El promedio parecía claro hasta ver cada ejecución individual; el gráfico de abajo muestra lo que variaron. Tres ejecuciones bastan para explicar lo que pasó aquí, no para predecir la latencia en producción.
Los tiempos variaron en ambos modos. Imagen del autor.
¿Por qué las comprobaciones concurrentes causaron una condición de carrera?
Ejecutar a la vez la comprobación de navegador y la prueba de importación masiva hacía que a veces fallara la aserción de importación porque ambas modificaban la misma lista de tareas en memoria. Eso rompió la suposición de acceso exclusivo del test. Aislar los datos en el runner o en los tests evitaría la condición de carrera.
Uso de ordenador acotado con GPT-6 Astra para pruebas de UI
Para el uso del ordenador, la documentación de GPT-6 Astra recomienda ejecución de código, mientras que la herramienta estructurada computer sigue admitida como alternativa. Con ejecución de código, una llamada puede combinar varias acciones, bucles y lógica condicional; la herramienta computer devuelve una acción estructurada de ratón o teclado por vez para que tu app la traduzca y reprograme.
Cómo limitar el runner de uso del ordenador
Llamé a la clase BrowserSandbox, pero el nombre exagera su protección. Da al código redactado por el modelo una page de Playwright, una función log() y un helper expect_text() . Python aún puede inyectar built-ins en exec(), y la página puede navegar a otro origen.
sandbox_globals = {"page": self.page, "log": log, "expect_text": expect_text}
exec(code, sandbox_globals)Trátalo como un runner de demo, no como un límite de seguridad. El código redactado por el modelo necesita un proceso o contenedor aislado con restricciones de sistema de archivos, procesos, red y orígenes.
¿Qué ocurrió en la comprobación de UI?
Tope el bucle en ocho turnos porque una comprobación acotada necesita un corte duro. El modelo inspeccionó la página, encontró el input del formulario, creó el título "UI flow check, cobalt otter 73921", envió la tarea y confirmó que aparecía; tardó 13 segundos. Nuestro tutorial de uso del ordenador con GPT-5.4 cubre un ejemplo detallado con un predecesor de Astra.
¿Cómo funciona el steering a mitad de turno en GPT-6 Astra?
El steering a mitad de turno está disponible solo para gpt-6-astra mediante conexión WebSocket.
Abre una conexión y crea una respuesta, luego envía un evento response.steer con nuevas instrucciones mientras se genera la respuesta. Un evento response.steer.accepted significa que la actualización está en cola, no aplicada. Antes de crear la continuación automática, el servidor termina el elemento de salida actual y cualquier trabajo de herramienta alojada ya en ejecución.
Si aún necesita el resultado de una herramienta del cliente o una aprobación, response.steer.pending identifica la entrada que falta.
async with client.responses.connect() as connection:
await connection.response.create(model="gpt-6-astra", input=TASK)
async for event in connection:
if event.type == "response.created" and initial_response_id is None:
initial_response_id = event.response.id
await asyncio.sleep(1.0)
await connection.response.steer(
previous_response_id=initial_response_id,
input="Also add a rollback plan, but skip mobile.",
)El retardo de un segundo replica el código del experimento y da tiempo a que empiece la primera respuesta. Sin ese retardo, probarías otro punto del ciclo de vida de la respuesta.
¿Qué no cambia el steering a mitad de turno?
El steering no reescribe la respuesta original. Si la actualización la interrumpe, esa respuesta termina con status: "incomplete" y incomplete_details.reason: "steered". Una respuesta sucesora continúa con la nueva instrucción.
Si la primera respuesta termina antes de que la actualización surta efecto, se mantiene completada. El steering no revierte ni cancela acciones del lado del cliente que ya hayan empezado; tu aplicación sigue siendo responsable. El steering en cola solo existe en la conexión WebSocket actual, así que registra la actualización antes de intentar reconectar.
La ruta de comparación deja que la primera respuesta termine y luego envía una nueva petición con las instrucciones combinadas. En dos ejecuciones, el steering promedió 26,91 segundos frente a 50,02 segundos de la vía de finalizar y reiniciar. Esta comparación no cubre una política de cancelar y reiniciar ni puntúa el texto final por corrección.
Promedios de dos ejecuciones para tiempo y coste. Imagen del autor.
La ruta de reinicio genera dos respuestas completas que cubren parte de las mismas peticiones. Eso explica parte de la diferencia de tiempo, así que no tomaría estas dos ejecuciones como benchmark general del steering.
Cómo cambiar el esfuerzo de razonamiento de GPT-6 Astra a mitad de conversación
gpt-6-astra admite esfuerzo de razonamiento de low a max. Un mayor esfuerzo puede aumentar el uso de tokens de razonamiento, pero no garantiza una respuesta distinta. Una configuration_update cambia las respuestas siguientes hasta que otra actualización la sobrescriba, mientras el ajuste al nivel de petición permanece igual.
En esta canalización, el informe cierra la conversación, así que la actualización afecta solo a ese último paso.
response = client.responses.create(
model="gpt-6-astra",
previous_response_id=previous_id,
reasoning={"effort": "low"}, # default remains low
input=[
{"type": "configuration_update", "reasoning": {"effort": "high"}},
{"role": "user", "content": "Diagnose the root cause and recommend a fix."},
],
)Usé la misma traza de fallo en ambos niveles de esfuerzo y comparé el diagnóstico y el uso de tokens.
Un matiz: el campo reasoning.effort de la respuesta sigue informando del ajuste al nivel de petición, no del esfuerzo seleccionado por configuration_update. No uses ese campo para verificar si la actualización surtió efecto.
¿Cambió el diagnóstico con un esfuerzo alto?
En la ejecución combinada completa, el paso escalado usó 108 tokens de razonamiento. Todos los demás pasos en low usaron cero. En una prueba aislada anterior con una traza de fallo más larga, el esfuerzo bajo usó cero tokens de razonamiento y el alto 318. Ambas versiones identificaron el bug de validación, así que subir el esfuerzo cambió el uso de tokens pero no el diagnóstico.
Las actualizaciones de configuración funcionan solo en peticiones estándar de un solo agente. La API rechaza actualizaciones adyacentes y no se pueden combinar con compactación o truncado automáticos.
Cómo usar las salidas estructuradas de GPT-6 Astra
El último paso de la canalización llama a client.responses.parse para sustituir texto libre por un modelo validado de Pydantic.
class GoNoGoReport(BaseModel):
decision: str
summary: str
checks_completed: list[str]
failures: list[str]
risks: list[str]
follow_up_actions: list[str]
confidence: float
response = client.responses.parse(
model="gpt-6-astra",
previous_response_id=previous_id,
text_format=GoNoGoReport,
input=[...],
)Pydantic valida los tipos de campo declarados aquí. No prueba que el informe se ajuste a las evidencias, y esta versión no restringe decision a dos valores ni confidence a un rango.
¿Qué detectó el informe go/no-go?
El informe devolvió decision: "no_go". Clasificó el fallo de validación mencionado antes en failures y el problema de concurrencia en risks. Para este último, escribió: "possible interference from concurrent UI checks against shared staging data." El prompt no nombraba ese riesgo.
Mantén latencia y coste fuera de este esquema y calcúlalos en código. El modelo rellena los campos del informe a partir de la evidencia de herramientas.
La interfaz de Streamlit consume el mismo generador que el runner por línea de comandos. Renderiza cada evento de herramienta a medida que llega y luego muestra el informe parseado en las pestañas Informe y JSON.