Code Interpreter

Code Interpreter para ejecución de código

Code Interpreter es una herramienta especializada que permite a los modelos de OpenAI escribir y ejecutar código Python en un entorno completamente aislado. A diferencia de las function calls tradicionales, esta herramienta proporciona un sandbox completo donde el modelo puede ejecutar código de forma iterativa, procesar archivos y generar contenido dinámico.

La principal ventaja de Code Interpreter radica en su capacidad para resolver problemas complejos que requieren múltiples pasos de cálculo, análisis de datos o manipulación de archivos. El modelo puede escribir código, ejecutarlo, analizar los resultados y modificar su aproximación según sea necesario.

Configuración básica

Para utilizar Code Interpreter con la API Responses, necesitas configurar la herramienta especificando un contenedor donde se ejecutará el código:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto"}
    }],
    instructions="Eres un asistente que resuelve problemas usando código Python.",
    input="Calcula la media y desviación estándar de estos números: 12, 15, 18, 22, 25, 28, 30"
)

print(response.output_text)

El parámetro container define el entorno de ejecución. El modo "auto" crea automáticamente un contenedor nuevo o reutiliza uno existente del contexto actual.

Ejemplo de uso:

Gestión de contenedores

Los contenedores son máquinas virtuales completamente aisladas donde se ejecuta el código Python. Puedes gestionarlos de dos formas:

Modo automático (recomendado para casos simples):

response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto"}
    }],
    input="Genera un gráfico de barras con los datos: A=10, B=15, C=8, D=12"
)

Modo explícito (para mayor control):

# Crear contenedor específico
container = client.containers.create(name="analisis-datos")

# Usar el contenedor en la respuesta
response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": container.id
    }],
    input="Analiza el dataset que subiré y genera estadísticas descriptivas"
)

print(f"Contenedor utilizado: {container.id}")

Casos de uso prácticos

Code Interpreter destaca en análisis de datos, donde puede procesar archivos CSV, generar visualizaciones y realizar cálculos estadísticos:

# Ejemplo: Análisis de ventas
response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto"}
    }],
    instructions="""
    Eres un analista de datos. Cuando recibas datos de ventas:
    1. Calcula métricas básicas (total, promedio, mediana)
    2. Identifica tendencias
    3. Genera un gráfico de líneas
    """,
    input="""
    Analiza estos datos de ventas mensuales:
    Enero: 15000, Febrero: 18000, Marzo: 12000, Abril: 22000, 
    Mayo: 25000, Junio: 19000, Julio: 28000, Agosto: 24000
    """
)

Para resolución de problemas matemáticos complejos:

response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto"}
    }],
    instructions="Resuelve problemas matemáticos paso a paso usando código Python.",
    input="""
    Encuentra las raíces de la ecuación cuadrática: 2x² - 7x + 3 = 0
    Además, grafica la función para visualizar las soluciones.
    """
)

Trabajo con archivos

Code Interpreter puede procesar archivos que subas al contenedor y generar nuevos archivos como resultado de sus operaciones. Los archivos se gestionan automáticamente:

# El modelo puede referenciar archivos por nombre
response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto", "files": ["file-abc123"]}
    }],
    input="Analiza el archivo CSV y genera un resumen ejecutivo con gráficos"
)

Cuando el modelo genera archivos (imágenes, CSV, reportes), estos aparecen como anotaciones en la respuesta:

# Procesar las anotaciones para obtener archivos generados
for content in response.content:
    if hasattr(content, 'annotations'):
        for annotation in content.annotations:
            if annotation.type == "container_file_citation":
                print(f"Archivo generado: {annotation.filename}")
                print(f"ID del archivo: {annotation.file_id}")
                print(f"Contenedor: {annotation.container_id}")

Ejecución iterativa

Una característica distintiva de Code Interpreter es su capacidad de ejecución iterativa. El modelo puede escribir código, ejecutarlo, analizar errores y corregir su aproximación:

response = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "code_interpreter",
        "container": {"type": "auto"}
    }],
    instructions="""
    Si encuentras errores en el código, corrígelos y vuelve a ejecutar.
    Explica cada paso del proceso de depuración.
    """,
    input="""
    Crea una función que calcule el factorial de un número y pruébala 
    con varios valores. Si hay errores, corrígelos automáticamente.
    """
)

Consideraciones importantes

Los contenedores tienen un tiempo de vida limitado de 20 minutos de inactividad. Después de este período, el contenedor expira y todos los datos se pierden:

# Verificar estado del contenedor
container_info = client.containers.retrieve(container.id)
print(f"Último uso: {container_info.last_active_at}")
print(f"Estado: {container_info.status}")

Para descargar archivos generados antes de que expire el contenedor:

# Listar archivos en el contenedor
files = client.containers.files.list(container.id)

# Descargar archivo específico
file_content = client.containers.files.content(
    container_id=container.id,
    file_id="file_id_here"
)

# Guardar localmente
with open("resultado.png", "wb") as f:
    f.write(file_content)

Code Interpreter transforma la interacción con modelos de IA al permitir computación real dentro del flujo de conversación, abriendo posibilidades para análisis de datos, visualización, cálculos complejos y automatización de tareas que requieren procesamiento computacional.