Loading...
    • Guía para desarrolladores
    • Referencia de API
    • MCP
    • Recursos
    • Notas de la versión
    Search...
    ⌘K
    Primeros pasos
    Introducción a ClaudeInicio rápido
    Modelos y precios
    Descripción general de modelosElegir un modeloNovedades en Claude 4.5Migración a Claude 4.5Deprecación de modelosPrecios
    Construir con Claude
    Descripción general de característicasUsar la API de MessagesVentanas de contextoMejores prácticas de prompting
    Capacidades
    Almacenamiento en caché de promptsEdición de contextoPensamiento extendidoEsfuerzoStreaming de MessagesProcesamiento por lotesCitasSoporte multilingüeConteo de tokensEmbeddingsVisiónSoporte de PDFAPI de FilesResultados de búsquedaSalidas estructuradasComplemento de Google Sheets
    Herramientas
    Descripción generalCómo implementar el uso de herramientasUso eficiente de herramientas en tokensStreaming de herramientas de grano finoHerramienta BashHerramienta de ejecución de códigoLlamada de herramientas programáticaHerramienta de uso de computadoraHerramienta de editor de textoHerramienta de búsqueda webHerramienta de búsqueda webHerramienta de memoriaHerramienta de búsqueda de herramientas
    Habilidades del agente
    Descripción generalInicio rápidoMejores prácticasUsar habilidades con la API
    SDK del agente
    Descripción generalSDK de TypeScriptSDK de PythonGuía de migración
    Guías
    Entrada de streamingManejo de permisosGestión de sesionesSalidas estructuradas en el SDKAlojamiento del SDK del agenteModificar prompts del sistemaMCP en el SDKHerramientas personalizadasSuagentes en el SDKComandos de barra en el SDKHabilidades del agente en el SDKSeguimiento de costos y usoListas de tareasComplementos en el SDK
    MCP en la API
    Conector MCPServidores MCP remotos
    Claude en plataformas de terceros
    Amazon BedrockMicrosoft FoundryVertex AI
    Ingeniería de prompts
    Descripción generalGenerador de promptsUsar plantillas de promptsMejorador de promptsSé claro y directoUsar ejemplos (prompting multishot)Dejar pensar a Claude (CoT)Usar etiquetas XMLDale un rol a Claude (prompts del sistema)Rellenar la respuesta de ClaudeEncadenar prompts complejosConsejos de contexto largoConsejos de pensamiento extendido
    Probar y evaluar
    Definir criterios de éxitoDesarrollar casos de pruebaUsar la herramienta de evaluaciónReducir latencia
    Fortalecer protecciones
    Reducir alucinacionesAumentar consistencia de salidaMitigar ataques de jailbreakRechazos de streamingReducir fuga de promptsMantener a Claude en personaje
    Administración y monitoreo
    Descripción general de Admin APIAPI de uso y costosAPI de análisis de Claude Code
    Console
    Log in
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...

    Solutions

    • AI agents
    • Code modernization
    • Coding
    • Customer support
    • Education
    • Financial services
    • Government
    • Life sciences

    Partners

    • Amazon Bedrock
    • Google Cloud's Vertex AI

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Company

    • Anthropic
    • Careers
    • Economic Futures
    • Research
    • News
    • Responsible Scaling Policy
    • Security and compliance
    • Transparency

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Help and security

    • Availability
    • Status
    • Support
    • Discord

    Terms and policies

    • Privacy policy
    • Responsible disclosure policy
    • Terms of service: Commercial
    • Terms of service: Consumer
    • Usage policy
    Herramientas

    Herramienta de ejecución de código

    Claude puede analizar datos, crear visualizaciones, realizar cálculos complejos, ejecutar comandos del sistema, crear y editar archivos, y procesar archivos cargados directamente dentro de la conversación de la API.

    Claude puede analizar datos, crear visualizaciones, realizar cálculos complejos, ejecutar comandos del sistema, crear y editar archivos, y procesar archivos cargados directamente dentro de la conversación de la API. La herramienta de ejecución de código permite que Claude ejecute comandos Bash y manipule archivos, incluida la escritura de código, en un entorno seguro y aislado.

    La herramienta de ejecución de código está actualmente en beta pública.

    Para usar esta función, añade el encabezado beta "code-execution-2025-08-25" beta header a tus solicitudes de API.

    Compatibilidad de modelos

    La herramienta de ejecución de código está disponible en los siguientes modelos:

    ModeloVersión de herramienta
    Claude Opus 4.5 (claude-opus-4-5-20251101)code_execution_20250825
    Claude Opus 4.1 (claude-opus-4-1-20250805)code_execution_20250825
    Claude Opus 4 (claude-opus-4-20250514)code_execution_20250825
    Claude Sonnet 4.5 (claude-sonnet-4-5-20250929)code_execution_20250825
    Claude Sonnet 4 (claude-sonnet-4-20250514)code_execution_20250825
    Claude Sonnet 3.7 (claude-3-7-sonnet-20250219) (deprecated)code_execution_20250825
    Claude Haiku 4.5 (claude-haiku-4-5-20251001)code_execution_20250825
    Claude Haiku 3.5 (claude-3-5-haiku-latest)code_execution_20250825

    La versión actual code_execution_20250825 admite comandos Bash y operaciones de archivos. También está disponible una versión heredada code_execution_20250522 (solo Python). Consulta Upgrade to latest tool version para obtener detalles de migración.

    Las versiones de herramienta más antiguas no tienen garantía de ser compatibles hacia atrás con modelos más nuevos. Siempre usa la versión de herramienta que corresponda a tu versión de modelo.

    Inicio rápido

    Aquí hay un ejemplo simple que pide a Claude que realice un cálculo:

    Cómo funciona la ejecución de código

    Cuando añades la herramienta de ejecución de código a tu solicitud de API:

    1. Claude evalúa si la ejecución de código ayudaría a responder tu pregunta
    2. La herramienta proporciona automáticamente a Claude las siguientes capacidades:
      • Comandos Bash: Ejecuta comandos de shell para operaciones del sistema y gestión de paquetes
      • Operaciones de archivos: Crea, visualiza y edita archivos directamente, incluida la escritura de código
    3. Claude puede usar cualquier combinación de estas capacidades en una única solicitud
    4. Todas las operaciones se ejecutan en un entorno sandbox seguro
    5. Claude proporciona resultados con cualquier gráfico generado, cálculos o análisis

    Cómo usar la herramienta

    Ejecutar comandos Bash

    Pide a Claude que verifique la información del sistema e instale paquetes:

    Crear y editar archivos directamente

    Claude puede crear, visualizar y editar archivos directamente en el sandbox usando las capacidades de manipulación de archivos:

    Cargar y analizar tus propios archivos

    Para analizar tus propios archivos de datos (CSV, Excel, imágenes, etc.), cárgalos a través de la API de Archivos y haz referencia a ellos en tu solicitud:

    Usar la API de Archivos con Ejecución de Código requiere dos encabezados beta: "anthropic-beta": "code-execution-2025-08-25,files-api-2025-04-14"

    El entorno de Python puede procesar varios tipos de archivos cargados a través de la API de Archivos, incluyendo:

    • CSV
    • Excel (.xlsx, .xls)
    • JSON
    • XML
    • Imágenes (JPEG, PNG, GIF, WebP)
    • Archivos de texto (.txt, .md, .py, etc)

    Cargar y analizar archivos

    1. Carga tu archivo usando la API de Archivos
    2. Haz referencia al archivo en tu mensaje usando un bloque de contenido container_upload
    3. Incluye la herramienta de ejecución de código en tu solicitud de API

    Recuperar archivos generados

    Cuando Claude crea archivos durante la ejecución de código, puedes recuperar estos archivos usando la API de Archivos:

    Combinar operaciones

    Un flujo de trabajo complejo usando todas las capacidades:

    Definición de herramienta

    La herramienta de ejecución de código no requiere parámetros adicionales:

    JSON
    {
      "type": "code_execution_20250825",
      "name": "code_execution"
    }

    Cuando se proporciona esta herramienta, Claude obtiene automáticamente acceso a dos sub-herramientas:

    • bash_code_execution: Ejecuta comandos de shell
    • text_editor_code_execution: Visualiza, crea y edita archivos, incluida la escritura de código

    Formato de respuesta

    La herramienta de ejecución de código puede devolver dos tipos de resultados dependiendo de la operación:

    Respuesta de comando Bash

    {
      "type": "server_tool_use",
      "id": "srvtoolu_01B3C4D5E6F7G8H9I0J1K2L3",
      "name": "bash_code_execution",
      "input": {
        "command": "ls -la | head -5"
      }
    },
    {
      "type": "bash_code_execution_tool_result",
      "tool_use_id": "srvtoolu_01B3C4D5E6F7G8H9I0J1K2L3",
      "content": {
        "type": "bash_code_execution_result",
        "stdout": "total 24\ndrwxr-xr-x 2 user user 4096 Jan 1 12:00 .\ndrwxr-xr-x 3 user user 4096 Jan 1 11:00 ..\n-rw-r--r-- 1 user user  220 Jan 1 12:00 data.csv\n-rw-r--r-- 1 user user  180 Jan 1 12:00 config.json",
        "stderr": "",
        "return_code": 0
      }
    }

    Respuestas de operación de archivo

    Ver archivo:

    {
      "type": "server_tool_use",
      "id": "srvtoolu_01C4D5E6F7G8H9I0J1K2L3M4",
      "name": "text_editor_code_execution",
      "input": {
        "command": "view",
        "path": "config.json"
      }
    },
    {
      "type": "text_editor_code_execution_tool_result",
      "tool_use_id": "srvtoolu_01C4D5E6F7G8H9I0J1K2L3M4",
      "content": {
        "type": "text_editor_code_execution_result",
        "file_type": "text",
        "content": "{\n  \"setting\": \"value\",\n  \"debug\": true\n}",
        "numLines": 4,
        "startLine": 1,
        "totalLines": 4
      }
    }

    Crear archivo:

    {
      "type": "server_tool_use",
      "id": "srvtoolu_01D5E6F7G8H9I0J1K2L3M4N5",
      "name": "text_editor_code_execution",
      "input": {
        "command": "create",
        "path": "new_file.txt",
        "file_text": "Hello, World!"
      }
    },
    {
      "type": "text_editor_code_execution_tool_result",
      "tool_use_id": "srvtoolu_01D5E6F7G8H9I0J1K2L3M4N5",
      "content": {
        "type": "text_editor_code_execution_result",
        "is_file_update": false
      }
    }

    Editar archivo (str_replace):

    {
      "type": "server_tool_use",
      "id": "srvtoolu_01E6F7G8H9I0J1K2L3M4N5O6",
      "name": "text_editor_code_execution",
      "input": {
        "command": "str_replace",
        "path": "config.json",
        "old_str": "\"debug\": true",
        "new_str": "\"debug\": false"
      }
    },
    {
      "type": "text_editor_code_execution_tool_result",
      "tool_use_id": "srvtoolu_01E6F7G8H9I0J1K2L3M4N5O6",
      "content": {
        "type": "text_editor_code_execution_result",
        "oldStart": 3,
        "oldLines": 1,
        "newStart": 3,
        "newLines": 1,
        "lines": ["-  \"debug\": true", "+  \"debug\": false"]
      }
    }

    Resultados

    Todos los resultados de ejecución incluyen:

    • stdout: Salida de ejecución exitosa
    • stderr: Mensajes de error si la ejecución falla
    • return_code: 0 para éxito, distinto de cero para fallo

    Campos adicionales para operaciones de archivo:

    • Ver: file_type, content, numLines, startLine, totalLines
    • Crear: is_file_update (si el archivo ya existía)
    • Editar: oldStart, oldLines, newStart, newLines, lines (formato diff)

    Errores

    Cada tipo de herramienta puede devolver errores específicos:

    Errores comunes (todas las herramientas):

    {
      "type": "bash_code_execution_tool_result",
      "tool_use_id": "srvtoolu_01VfmxgZ46TiHbmXgy928hQR",
      "content": {
        "type": "bash_code_execution_tool_result_error",
        "error_code": "unavailable"
      }
    }

    Códigos de error por tipo de herramienta:

    HerramientaCódigo de errorDescripción
    Todas las herramientasunavailableLa herramienta no está disponible temporalmente
    Todas las herramientasexecution_time_exceededLa ejecución excedió el límite de tiempo máximo
    Todas las herramientascontainer_expiredEl contenedor expiró y ya no está disponible
    Todas las herramientasinvalid_tool_inputParámetros inválidos proporcionados a la herramienta
    Todas las herramientastoo_many_requestsLímite de velocidad excedido para el uso de la herramienta
    text_editorfile_not_found

    Razón de parada pause_turn

    La respuesta puede incluir una razón de parada pause_turn, que indica que la API pausó un turno de larga duración. Puedes proporcionar la respuesta tal como está en una solicitud posterior para permitir que Claude continúe su turno, o modificar el contenido si deseas interrumpir la conversación.

    Contenedores

    La herramienta de ejecución de código se ejecuta en un entorno containerizado seguro diseñado específicamente para la ejecución de código, con un enfoque más alto en Python.

    Entorno de ejecución

    • Versión de Python: 3.11.12
    • Sistema operativo: Contenedor basado en Linux
    • Arquitectura: x86_64 (AMD64)

    Límites de recursos

    • Memoria: 5GiB RAM
    • Espacio en disco: 5GiB de almacenamiento de espacio de trabajo
    • CPU: 1 CPU

    Redes y seguridad

    • Acceso a Internet: Completamente deshabilitado por seguridad
    • Conexiones externas: No se permiten solicitudes de red salientes
    • Aislamiento de sandbox: Aislamiento completo del sistema host y otros contenedores
    • Acceso a archivos: Limitado solo al directorio de espacio de trabajo
    • Alcance del espacio de trabajo: Como Archivos, los contenedores están limitados al espacio de trabajo de la clave de API
    • Expiración: Los contenedores expiran 30 días después de su creación

    Bibliotecas preinstaladas

    El entorno de Python aislado incluye estas bibliotecas comúnmente utilizadas:

    • Ciencia de datos: pandas, numpy, scipy, scikit-learn, statsmodels
    • Visualización: matplotlib, seaborn
    • Procesamiento de archivos: pyarrow, openpyxl, xlsxwriter, xlrd, pillow, python-pptx, python-docx, pypdf, pdfplumber, pypdfium2, pdf2image, pdfkit, tabula-py, reportlab[pycairo], Img2pdf
    • Matemáticas y computación: sympy, mpmath
    • Utilidades: tqdm, python-dateutil, pytz, joblib, unzip, unrar, 7zip, bc, rg (ripgrep), fd, sqlite

    Reutilización de contenedores

    Puedes reutilizar un contenedor existente en múltiples solicitudes de API proporcionando el ID del contenedor de una respuesta anterior. Esto te permite mantener archivos creados entre solicitudes.

    Ejemplo

    Transmisión

    Con la transmisión habilitada, recibirás eventos de ejecución de código a medida que ocurren:

    event: content_block_start
    data: {"type": "content_block_start", "index": 1, "content_block": {"type": "server_tool_use", "id": "srvtoolu_xyz789", "name": "code_execution"}}
    
    // Ejecución de código transmitida
    event: content_block_delta
    data: {"type": "content_block_delta", "index": 1, "delta": {"type": "input_json_delta", "partial_json": "{\"code\":\"import pandas as pd\\ndf = pd.read_csv('data.csv')\\nprint(df.head())\"}"}}
    
    // Pausa mientras se ejecuta el código
    
    // Resultados de ejecución transmitidos
    event: content_block_start
    data: {"type": "content_block_start", "index": 2, "content_block": {"type": "code_execution_tool_result", "tool_use_id": "srvtoolu_xyz789", "content": {"stdout": "   A  B  C\n0  1  2  3\n1  4  5  6", "stderr": ""}}}

    Solicitudes por lotes

    Puedes incluir la herramienta de ejecución de código en la API de Lotes de Mensajes. Las llamadas de herramienta de ejecución de código a través de la API de Lotes de Mensajes se cotizan igual que las de las solicitudes regulares de la API de Mensajes.

    Uso y precios

    Code execution tool usage is tracked separately from token usage. Execution time has a minimum of 5 minutes. If files are included in the request, execution time is billed even if the tool is not used due to files being preloaded onto the container.

    Each organization receives 50 free hours of usage with the code execution tool per day. Additional usage beyond the first 50 hours is billed at $0.05 per hour, per container.

    Actualizar a la versión más reciente de la herramienta

    Al actualizar a code-execution-2025-08-25, obtienes acceso a manipulación de archivos y capacidades de Bash, incluido código en múltiples idiomas. No hay diferencia de precio.

    Qué ha cambiado

    ComponenteHeredadoActual
    Encabezado betacode-execution-2025-05-22code-execution-2025-08-25
    Tipo de herramientacode_execution_20250522code_execution_20250825
    CapacidadesSolo PythonComandos Bash, operaciones de archivos
    Tipos de respuestacode_execution_resultbash_code_execution_result, text_editor_code_execution_result

    Compatibilidad hacia atrás

    • Todo el código Python de ejecución existente continúa funcionando exactamente como antes
    • No se requieren cambios en los flujos de trabajo existentes solo de Python

    Pasos de actualización

    Para actualizar, necesitas hacer los siguientes cambios en tus solicitudes de API:

    1. Actualiza el encabezado beta:

      - "anthropic-beta": "code-execution-2025-05-22"
      + "anthropic-beta": "code-execution-2025-08-25"
    2. Actualiza el tipo de herramienta:

      - "type": "code_execution_20250522"
      + "type": "code_execution_20250825"
    3. Revisa el manejo de respuestas (si analizas respuestas programáticamente):

      • Los bloques anteriores para respuestas de ejecución de Python ya no se enviarán
      • En su lugar, se enviarán nuevos tipos de respuesta para operaciones de Bash y archivos (consulta la sección Formato de respuesta)

    Llamada de herramienta programática

    La herramienta de ejecución de código potencia la llamada de herramienta programática, que permite que Claude escriba código que llame a tus herramientas personalizadas de forma programática dentro del contenedor de ejecución. Esto permite flujos de trabajo eficientes de múltiples herramientas, filtrado de datos antes de llegar al contexto de Claude, y lógica condicional compleja.

    Python
    # Habilita la llamada programática para tus herramientas
    response = client.beta.messages.create(
        model="claude-sonnet-4-5",
        betas=["advanced-tool-use-2025-11-20"],
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": "Get weather for 5 cities and find the warmest"
        }],
        tools=[
            {
                "type": "code_execution_20250825",
                "name": "code_execution"
            },
            {
                "name": "get_weather",
                "description": "Get weather for a city",
                "input_schema": {...},
                "allowed_callers": ["code_execution_20250825"]  # Habilita la llamada programática
            }
        ]
    )

    Obtén más información en la documentación de llamada de herramienta programática.

    Usar ejecución de código con Habilidades de Agente

    La herramienta de ejecución de código permite que Claude use Habilidades de Agente. Las habilidades son capacidades modulares que consisten en instrucciones, scripts y recursos que extienden la funcionalidad de Claude.

    Obtén más información en la documentación de Habilidades de Agente y la guía de API de Habilidades de Agente.

    • Compatibilidad de modelos
    • Inicio rápido
    • Cómo funciona la ejecución de código
    • Cómo usar la herramienta
    • Ejecutar comandos Bash
    • Crear y editar archivos directamente
    • Cargar y analizar tus propios archivos
    • Combinar operaciones
    • Definición de herramienta
    • Formato de respuesta
    • Respuesta de comando Bash
    • Respuestas de operación de archivo
    • Resultados
    • Errores
    • Contenedores
    • Entorno de ejecución
    • Límites de recursos
    • Redes y seguridad
    • Bibliotecas preinstaladas
    • Reutilización de contenedores
    • Ejemplo
    • Transmisión
    • Solicitudes por lotes
    • Uso y precios
    • Actualizar a la versión más reciente de la herramienta
    • Qué ha cambiado
    • Compatibilidad hacia atrás
    • Pasos de actualización
    • Llamada de herramienta programática
    • Usar ejecución de código con Habilidades de Agente
    curl https://api.anthropic.com/v1/messages \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: code-execution-2025-08-25" \
        --header "content-type: application/json" \
        --data '{
            "model": "claude-sonnet-4-5",
            "max_tokens": 4096,
            "messages": [
                {
                    "role": "user",
                    "content": "Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
                }
            ],
            "tools": [{
                "type": "code_execution_20250825",
                "name": "code_execution"
            }]
        }'
    curl https://api.anthropic.com/v1/messages \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: code-execution-2025-08-25" \
        --header "content-type: application/json" \
        --data '{
            "model": "claude-sonnet-4-5",
            "max_tokens": 4096,
            "messages": [{
                "role": "user",
                "content": "Check the Python version and list installed packages"
            }],
            "tools": [{
                "type": "code_execution_20250825",
                "name": "code_execution"
            }]
        }'
    curl https://api.anthropic.com/v1/messages \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: code-execution-2025-08-25" \
        --header "content-type: application/json" \
        --data '{
            "model": "claude-sonnet-4-5",
            "max_tokens": 4096,
            "messages": [{
                "role": "user",
                "content": "Create a config.yaml file with database settings, then update the port from 5432 to 3306"
            }],
            "tools": [{
                "type": "code_execution_20250825",
                "name": "code_execution"
            }]
        }'
    # Primero, carga un archivo
    curl https://api.anthropic.com/v1/files \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: files-api-2025-04-14" \
        --form 'file=@"data.csv"' \
    
    # Luego usa el file_id con ejecución de código
    curl https://api.anthropic.com/v1/messages \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: code-execution-2025-08-25,files-api-2025-04-14" \
        --header "content-type: application/json" \
        --data '{
            "model": "claude-sonnet-4-5",
            "max_tokens": 4096,
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "text", "text": "Analyze this CSV data"},
                    {"type": "container_upload", "file_id": "file_abc123"}
                ]
            }],
            "tools": [{
                "type": "code_execution_20250825",
                "name": "code_execution"
            }]
        }'
    from anthropic import Anthropic
    
    # Inicializa el cliente
    client = Anthropic()
    
    # Solicita ejecución de código que crea archivos
    response = client.beta.messages.create(
        model="claude-sonnet-4-5",
        betas=["code-execution-2025-08-25", "files-api-2025-04-14"],
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": "Create a matplotlib visualization and save it as output.png"
        }],
        tools=[{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    )
    
    # Extrae IDs de archivo de la respuesta
    def extract_file_ids(response):
        file_ids = []
        for item in response.content:
            if item.type == 'bash_code_execution_tool_result':
                content_item = item.content
                if content_item.type == 'bash_code_execution_result':
                    for file in content_item.content:
                        if hasattr(file, 'file_id'):
                            file_ids.append(file.file_id)
        return file_ids
    
    # Descarga los archivos creados
    for file_id in extract_file_ids(response):
        file_metadata = client.beta.files.retrieve_metadata(file_id)
        file_content = client.beta.files.download(file_id)
        file_content.write_to_file(file_metadata.filename)
        print(f"Downloaded: {file_metadata.filename}")
    # Primero, carga un archivo
    curl https://api.anthropic.com/v1/files \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: files-api-2025-04-14" \
        --form 'file=@"data.csv"' \
        > file_response.json
    
    # Extrae file_id (usando jq)
    FILE_ID=$(jq -r '.id' file_response.json)
    
    # Luego úsalo con ejecución de código
    curl https://api.anthropic.com/v1/messages \
        --header "x-api-key: $ANTHROPIC_API_KEY" \
        --header "anthropic-version: 2023-06-01" \
        --header "anthropic-beta: code-execution-2025-08-25,files-api-2025-04-14" \
        --header "content-type: application/json" \
        --data '{
            "model": "claude-sonnet-4-5",
            "max_tokens": 4096,
            "messages": [{
                "role": "user",
                "content": [
                    {
                        "type": "text", 
                        "text": "Analyze this CSV data: create a summary report, save visualizations, and create a README with the findings"
                    },
                    {
                        "type": "container_upload", 
                        "file_id": "'$FILE_ID'"
                    }
                ]
            }],
            "tools": [{
                "type": "code_execution_20250825",
                "name": "code_execution"
            }]
        }'
    El archivo no existe (para operaciones de visualización/edición)
    text_editorstring_not_foundEl old_str no se encontró en el archivo (para str_replace)
    import os
    from anthropic import Anthropic
    
    # Inicializa el cliente
    client = Anthropic(
        api_key=os.getenv("ANTHROPIC_API_KEY")
    )
    
    # Primera solicitud: Crea un archivo con un número aleatorio
    response1 = client.beta.messages.create(
        model="claude-sonnet-4-5",
        betas=["code-execution-2025-08-25"],
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": "Write a file with a random number and save it to '/tmp/number.txt'"
        }],
        tools=[{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    )
    
    # Extrae el ID del contenedor de la primera respuesta
    container_id = response1.container.id
    
    # Segunda solicitud: Reutiliza el contenedor para leer el archivo
    response2 = client.beta.messages.create(
        container=container_id,  # Reutiliza el mismo contenedor
        model="claude-sonnet-4-5",
        betas=["code-execution-2025-08-25"],
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": "Read the number from '/tmp/number.txt' and calculate its square"
        }],
        tools=[{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    )