Intérprete de código: ejecuta código en la API
En esta página
- Intérprete de código: ejecuta código en la API
- Habilitar el Intérprete de código
- Inspeccionar el código ejecutado
- Proporcionar archivos como entrada
- Recuperar archivos generados
- Contenedor y entorno
- Encadenar múltiples ejecuciones
- Combinar con otras herramientas
- Patrón: canalización de análisis completa
- Puntos clave
Actualizado el 2 de noviembre de 2026 según la guía oficial del Intérprete de código y el SDK
openai: la herramienta requiere un parámetrocontainer(ausente en todos los ejemplos anteriores, lo que habría provocado fallos), los archivos generados aparecen en las anotacionescontainer_file_citationy se descargan mediante la API de Contenedores (no conclient.files.content), y las salidas de las llamadas se denominanoutputs(noresults). Las partes de texto de entrada usan el tipoinput_text. Los archivos adjuntos a un mensaje se suben con el propósitouser_data, que OpenAI recomienda para las entradas del modelo (Entradas de archivo). Fuentes: Intérprete de código · Entradas de archivo.
Intérprete de código: ejecuta código en la API
Un modelo de lenguaje predice texto; no calcula. Si le pides la raíz cuadrada de 1764, producirá el resultado más probable según su entrenamiento: a menudo correcto, a veces erróneo, sin forma de distinguir entre ambos casos. El Intérprete de código elimina esta incertidumbre al dotar al modelo de un intérprete de Python: escribe el cálculo, lo ejecuta y devuelve un resultado obtenido, no una suposición.
El cambio es más profundo de lo que parece. El modelo ve la salida de su propio código, incluidos los errores, por lo que puede corregirse y reintentarlo. Ante un archivo de datos cuya estructura exacta desconoce cualquiera, este bucle supera a cualquier instrucción preescrita.
Habilitar el Intérprete de código
Lo habilitas añadiendo la herramienta al array tools; no hay nada que instalar ni ningún entorno que aprovisionar. El modelo decide cuándo escribir código: responde directamente a preguntas factuales, pero cambia a la ejecución para cálculos o manipulación de datos.
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input="Calculate the Fibonacci sequence up to the 20th term",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)
El modelo escribe el código Python, lo ejecuta en un entorno aislado (sandbox) e integra los resultados en su respuesta.
Inspeccionar el código ejecutado
Acostúmbrate a leer este código, al menos durante el desarrollo. Es la única forma de distinguir un buen resultado de uno acertado por casualidad: una media calculada ignorando silenciosamente valores faltantes es numéricamente correcta pero analíticamente falsa. La respuesta no te lo dirá; el código sí.
La respuesta contiene el código generado y sus resultados:
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the square root of 1764? Verify by squaring the result.",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
include=["code_interpreter_call.outputs"], # para recibir registros e imágenes producidos
)
for item in response.output:
if item.type == "code_interpreter_call":
print("--- Executed Code ---")
print(item.code)
print("--- Outputs ---")
for output in item.outputs or []:
print(output.logs if output.type == "logs" else output.url)
Proporcionar archivos como entrada
La herramienta ofrece todo su valor cuando trabaja con archivos. Subes el archivo, lo referencias en la llamada y el modelo lo abre realmente: lee las columnas reales, los tipos reales y los valores atípicos reales, en lugar de razonar sobre una descripción que podrías haber proporcionado.
# Subir el archivo
with open("sales_2025.csv", "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
# Usar el Intérprete de código con el archivo
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "Analyze this sales file. "
"Give me the total by category and the best-performing month."},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)
Recuperar archivos generados
El camino inverso también funciona: el código produce un CSV limpio, un gráfico o un libro de Excel, y estos archivos se te devuelven. Permanecen en el contenedor, y el mensaje de respuesta los cita en sus anotaciones de tipo container_file_citation, incluyendo el ID del contenedor, el ID del archivo y el nombre del archivo. Luego los descargas mediante la API de Contenedores. Dos pequeñas funciones, reutilizadas en lecciones posteriores, encapsulan este flujo:
def generated_files(response):
"""Archivos creados por el Intérprete de código, citados en las anotaciones del mensaje."""
for item in response.output:
if item.type == "message":
for part in item.content:
for ann in getattr(part, "annotations", None) or []:
if ann.type == "container_file_citation":
yield ann
def download(client, ann, path):
"""Descarga un archivo del contenedor y devuelve su ruta local."""
content = client.containers.files.content.retrieve(ann.file_id, container_id=ann.container_id)
with open(path, "wb") as out:
out.write(content.read())
return path
Los archivos que proporcionas como entrada (input_file) se copian automáticamente en el contenedor: no necesitas subir nada más.
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "Create a chart of sales by month "
"and export the cleaned data as a CSV."},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# Recuperar archivos generados
for ann in generated_files(response):
print(f"Generated file: {ann.filename}")
download(client, ann, ann.filename)
Contenedor y entorno
Conocer las reglas del contenedor te ahorra tiempo depurando lo que no puede funcionar. Según la documentación de OpenAI:
- es una máquina virtual totalmente aislada (sandbox) donde el modelo ejecuta Python;
- la herramienta requiere un parámetro
container:{"type": "auto"}crea un contenedor (o reutiliza uno de una llamada anterior presente en el contexto), mientras que un ID obtenido medianteclient.containers.create(...)fuerza un contenedor específico; - la memoria se configura con
memory_limit:1g(predeterminado),4g,16go64g, y los niveles superiores se facturan a las tarifas de herramientas integradas; - un contenedor caduca tras 20 minutos de inactividad; sus datos se pierden entonces, así que descarga cualquier archivo que quieras conservar mientras esté activo.
No cuentes con acceso a la red desde el código: proporciona los datos como entrada o delega la investigación en la herramienta Búsqueda web.
# Ejemplo: el modelo puede usar pandas directamente
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "Load this CSV with pandas, "
"calculate descriptive statistics, and identify outliers."},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
Encadenar múltiples ejecuciones
Las ejecuciones sucesivas comparten la misma sesión: las variables, los DataFrames y las importaciones del primer bloque permanecen disponibles en el siguiente, exactamente igual que en un cuaderno (notebook). El modelo aprovecha esto de forma natural: carga, inspecciona y luego procesa, lo que hace posible un análisis en varios pasos sin tener que recargar todo en cada etapa.
response = client.responses.create(
model="gpt-5.6-terra",
input="1. Generate 1000 random points from a normal distribution. "
"2. Calculate the mean and standard deviation. "
"3. Create a histogram. "
"4. Perform a Shapiro-Wilk normality test.",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# El modelo ejecuta 4 bloques de código secuencialmente
# Cada bloque tiene acceso a las variables de los anteriores
Combinar con otras herramientas
La combinación más útil empareja una fuente de datos con la capacidad de procesarla: Búsqueda de archivos encuentra el pasaje relevante en tus documentos, Búsqueda web aporta datos de mercado y el Intérprete de código compara ambos en una tabla o gráfico. Ninguna de estas herramientas puede hacer el trabajo de las otras.
response = client.responses.create(
model="gpt-5.6-terra",
input="Search the web for French GDP data from the last 10 years, "
"then create a trend chart with a linear regression.",
tools=[
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}}
]
)
Patrón: canalización de análisis completa
El ejemplo final encadena todo lo anterior en un caso realista: un archivo de entrada, un análisis en varios pasos y entregables de salida. Céntrate especialmente en el formato del prompt: numerado y explícito sobre la salida esperada, porque eso, mucho más que el código Python que lo acompaña, determina la calidad del resultado.
def analyze_data(file_path: str, questions: list[str]) -> dict:
"""Canalización de análisis de datos con el Intérprete de código."""
# Subir
with open(file_path, "rb") as f:
file_obj = client.files.create(file=f, purpose="user_data")
results = {}
for question in questions:
response = client.responses.create(
model="gpt-5.6-terra",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": question},
{"type": "input_file", "file_id": file_obj.id}
]
}
],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions="Write clean, commented Python code. "
"Display intermediate results."
)
results[question] = response.output_text
return results
# Uso
results = analyze_data("sales.csv", [
"Give descriptive statistics for each numeric column",
"What are the top 5 best-selling products?",
"Is there seasonality in sales?"
])
Puntos clave
- El Intérprete de código ejecuta Python en un contenedor aislado; el parámetro
containeres obligatorio ({"type": "auto"}o un ID) - Los archivos proporcionados como
input_filese copian automáticamente en el contenedor - Los archivos generados se citan como
container_file_citationy se descargan medianteclient.containers.files.content.retrieve - Un contenedor caduca tras 20 minutos de inactividad: descarga lo que quieras conservar
- Combínalo con Búsqueda web y Búsqueda de archivos para un análisis enriquecido