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

Intérprete de código: ejecuta código en la API

Lección 10 de 20 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Intérprete de código: ejecuta código en la API
  2. Habilitar el Intérprete de código
  3. Inspeccionar el código ejecutado
  4. Proporcionar archivos como entrada
  5. Recuperar archivos generados
  6. Contenedor y entorno
  7. Encadenar múltiples ejecuciones
  8. Combinar con otras herramientas
  9. Patrón: canalización de análisis completa
  10. 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ámetro container (ausente en todos los ejemplos anteriores, lo que habría provocado fallos), los archivos generados aparecen en las anotaciones container_file_citation y se descargan mediante la API de Contenedores (no con client.files.content), y las salidas de las llamadas se denominan outputs (no results). Las partes de texto de entrada usan el tipo input_text. Los archivos adjuntos a un mensaje se suben con el propósito user_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 mediante client.containers.create(...) fuerza un contenedor específico;
  • la memoria se configura con memory_limit: 1g (predeterminado), 4g, 16g o 64g, 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 container es obligatorio ({"type": "auto"} o un ID)
  • Los archivos proporcionados como input_file se copian automáticamente en el contenedor
  • Los archivos generados se citan como container_file_citation y se descargan mediante client.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