code-interpreter

What this skill does

# Code Interpreter

A general-purpose code execution environment powered by AWS Bedrock AgentCore Code Interpreter. Run code, execute shell commands, and manage files in a secure sandbox.

## Available Tools

- **execute_code(code, language, output_filename)**: Execute Python, JavaScript, or TypeScript code.
- **execute_command(command)**: Execute shell commands.
- **file_operations(operation, paths, content)**: Read, write, list, or remove files in the sandbox.
- **ci_push_to_workspace(paths)**: Save sandbox files to the shared workspace (S3). Omit `paths` to save all files in the sandbox root.

## Tool Parameters

### execute_code

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `code` | string | Yes | | Code to execute. Use `print()` for text output. |
| `language` | string | No | `"python"` | `"python"`, `"javascript"`, or `"typescript"` |
| `output_filename` | string | No | `""` | File to download after execution. Code must save a file with this exact name. Saved to workspace automatically. |

### execute_command

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `command` | string | Yes | Shell command to execute (e.g., `"ls -la"`, `"pip install requests"`). |

### file_operations

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `operation` | string | Yes | `"read"`, `"write"`, `"list"`, or `"remove"` |
| `paths` | list | For read/list/remove | File paths. read: `["file.txt"]`, list: `["."]`, remove: `["old.txt"]` |
| `content` | list | For write | Entries with `path` and `text`: `[{"path": "out.txt", "text": "hello"}]` |

## tool_input Examples

### execute_code — text output

```json
{
  "code": "import pandas as pd\ndf = pd.DataFrame({'A': [1,2,3], 'B': [4,5,6]})\nprint(df.describe())",
  "language": "python"
}
```

### execute_code — generate chart

```json
{
  "code": "import matplotlib\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\nimport numpy as np\nx = np.linspace(0, 10, 100)\nplt.figure(figsize=(10,6))\nplt.plot(x, np.sin(x))\nplt.title('Sine Wave')\nplt.savefig('sine.png', dpi=300, bbox_inches='tight')\nprint('Done')",
  "language": "python",
  "output_filename": "sine.png"
}
```

### execute_command — install a package

```json
{
  "command": "pip install yfinance"
}
```

### execute_command — check environment

```json
{
  "command": "python --version && pip list | head -20"
}
```

### file_operations — write a file

```json
{
  "operation": "write",
  "content": [{"path": "config.json", "text": "{\"key\": \"value\"}"}]
}
```

### file_operations — list files

```json
{
  "operation": "list",
  "paths": ["."]
}
```

### file_operations — read a file

```json
{
  "operation": "read",
  "paths": ["output.csv"]
}
```

## When to Use This Skill

Use code-interpreter as a **sandbox for testing and prototyping code**.
For production tasks (creating documents, charts, presentations), prefer specialized skills.

**Do NOT use for:**
- Formatting or displaying code examples (respond directly with markdown code blocks)
- Explaining code or algorithms (respond directly with text)
- Simple calculations you can do mentally (just provide the answer)
- Any task that doesn't require actual code execution

| Task | Recommended Skill | Notes |
|------|-------------------|-------|
| Create charts/diagrams | **visual-design** | Use this first for production charts |
| Create Word documents | **word-documents** | Has template support and styling |
| Create Excel spreadsheets | **excel-spreadsheets** | Has formatting pipeline and validation |
| Create PowerPoint | **powerpoint-presentations** | Has layout system and design patterns |
| **Test code snippets** | **code-interpreter** | Debug, verify logic, check output |
| **Prototype algorithms** | **code-interpreter** | Experiment before implementing |
| **Install/test packages** | **code-interpreter** | Check compatibility, test APIs |
| Debug code logic | code-interpreter | Isolate and test specific functions |
| Verify calculations | code-interpreter | Quick math or data checks |

## Code Interpreter vs Code Agent

| | Code Interpreter | Code Agent |
|---|---|---|
| **Nature** | Sandboxed execution environment | Autonomous agent (Claude Code) |
| **Best for** | Quick scripts, data analysis, prototyping | Multi-file projects, refactoring, test suites |
| **File persistence** | Only when `output_filename` is set | All files auto-synced to S3 |
| **Session state** | Variables persist within session | Files + conversation persist across sessions |
| **Autonomy** | You write the code | Agent plans, writes, runs, and iterates |
| **Use when** | You need to run a specific piece of code | You need an engineer to solve a problem end-to-end |

## Workspace Integration

All files go to the `code-interpreter/` namespace — a flat, session-isolated space separate from office documents.

**Sandbox → Workspace (save outputs):**

```json
// Save a specific file after execution
{ "tool": "ci_push_to_workspace", "paths": ["chart.png", "results.json"] }

// Save everything in the sandbox root
{ "tool": "ci_push_to_workspace" }

// Alternative: save a single file inline during execute_code
{ "tool": "execute_code", "output_filename": "chart.png", "code": "..." }
```

**Uploaded files (auto-preloaded):**

Files uploaded by the user (e.g. ZIP archives) are automatically available in the sandbox — no manual loading needed. Just use them directly in `execute_code`.

**Read saved files via workspace skill:**
```
workspace_read("code-interpreter/chart.png")
workspace_read("code-interpreter/results.json")
workspace_list("code-interpreter/")
```

> Text files (`.py`, `.csv`, `.json`, `.txt`, etc.) are transferred as-is.
> Binary files (`.png`, `.pdf`, `.xlsx`, etc.) are handled via base64 encoding automatically.

## Environment

- **Languages:** Python (recommended, 200+ libraries), JavaScript, TypeScript
- **Shell:** Full shell access via `execute_command`
- **File system:** Persistent within session; use `file_operations` to manage files
- **Session state:** Variables and files persist across multiple calls within the same session
- **Network:** Internet access available (can use `requests`, `urllib`, `curl`)

## Supported Languages

- **Python** (recommended) — 200+ pre-installed libraries covering data science, ML, visualization, file processing
- **JavaScript** — Node.js runtime, useful for JSON manipulation, async operations
- **TypeScript** — TypeScript runtime with type checking

## Pre-installed Python Libraries

### Data Analysis & Visualization

| Library | Common Use |
|---------|------------|
| `pandas` | DataFrames, CSV/Excel I/O, groupby, pivot |
| `numpy` | Arrays, linear algebra, random, statistics |
| `matplotlib` | Line, bar, scatter, histogram, subplots |
| `plotly` | Interactive charts, 3D plots |
| `bokeh` | Interactive visualization |
| `scipy` | Optimization, interpolation, signal processing |
| `statsmodels` | Regression, time series, hypothesis tests |
| `sympy` | Algebra, calculus, equation solving |

### Machine Learning & AI

| Library | Common Use |
|---------|------------|
| `scikit-learn` | Classification, regression, clustering, pipelines |
| `torch` / `torchvision` / `torchaudio` | Deep learning, computer vision, audio |
| `xgboost` | High-performance gradient boosting |
| `spacy` / `nltk` / `textblob` | NLP, tokenization, NER, sentiment |
| `scikit-image` | Image processing, filters, segmentation |

### Mathematical & Optimization

| Library | Common Use |
|---------|------------|
| `cvxpy` | Convex optimization, portfolio optimization |
| `ortools` | Scheduling, routing, constraint programming |
| `pulp` | Linear programming |
| `z3-solver` | SAT solving, formal verification |
| `networkx` / `igraph` | Graph algorithms, network analysis |

### File Processing & Documents

| Library | Common Use |
|---------|------------|
| `openp