Code Interpreter
The CodeInterpreterTool
is a powerful tool designed for executing Python 3 code within a secure, isolated environment.
CodeInterpreterTool
Description
The CodeInterpreterTool
enables CrewAI agents to execute Python 3 code that they generate autonomously. This functionality is particularly valuable as it allows agents to create code, execute it, obtain the results, and utilize that information to inform subsequent decisions and actions.
There are several ways to use this tool:
Docker Container (Recommended)
This is the primary option. The code runs in a secure, isolated Docker container, ensuring safety regardless of its content. Make sure Docker is installed and running on your system. If you don’t have it, you can install it from here.
Sandbox environment
If Docker is unavailable — either not installed or not accessible for any reason — the code will be executed in a restricted Python environment - called sandbox. This environment is very limited, with strict restrictions on many modules and built-in functions.
Unsafe Execution
NOT RECOMMENDED FOR PRODUCTION
This mode allows execution of any Python code, including dangerous calls to sys, os..
and similar modules. Check out how to enable this mode
Logging
The CodeInterpreterTool
logs the selected execution strategy to STDOUT
Installation
To use this tool, you need to install the CrewAI tools package:
Example
The following example demonstrates how to use the CodeInterpreterTool
with a CrewAI agent:
You can also enable code execution directly when creating an agent:
Enabling unsafe_mode
Parameters
The CodeInterpreterTool
accepts the following parameters during initialization:
- user_dockerfile_path: Optional. Path to a custom Dockerfile to use for the code interpreter container.
- user_docker_base_url: Optional. URL to the Docker daemon to use for running the container.
- unsafe_mode: Optional. Whether to run code directly on the host machine instead of in a Docker container or sandbox. Default is
False
. Use with caution! - default_image_tag: Optional. Default Docker image tag. Default is
code-interpreter:latest
When using the tool with an agent, the agent will need to provide:
- code: Required. The Python 3 code to execute.
- libraries_used: Optional. A list of libraries used in the code that need to be installed. Default is
[]
Agent Integration Example
Here’s a more detailed example of how to integrate the CodeInterpreterTool
with a CrewAI agent:
Implementation Details
The CodeInterpreterTool
uses Docker to create a secure environment for code execution:
The tool performs the following steps:
- Verifies that the Docker image exists or builds it if necessary
- Creates a Docker container with the current working directory mounted
- Installs any required libraries specified by the agent
- Executes the Python code in the container
- Returns the output of the code execution
- Cleans up by stopping and removing the container
Security Considerations
By default, the CodeInterpreterTool
runs code in an isolated Docker container, which provides a layer of security. However, there are still some security considerations to keep in mind:
- The Docker container has access to the current working directory, so sensitive files could potentially be accessed.
- If the Docker container is unavailable and the code needs to run safely, it will be executed in a sandbox environment. For security reasons, installing arbitrary libraries is not allowed
- The
unsafe_mode
parameter allows code to be executed directly on the host machine, which should only be used in trusted environments. - Be cautious when allowing agents to install arbitrary libraries, as they could potentially include malicious code.
Conclusion
The CodeInterpreterTool
provides a powerful way for CrewAI agents to execute Python code in a relatively secure environment. By enabling agents to write and run code, it significantly expands their problem-solving capabilities, especially for tasks involving data analysis, calculations, or other computational work. This tool is particularly useful for agents that need to perform complex operations that are more efficiently expressed in code than in natural language.