Pular para o conteúdo

Build an AI code executor

Atualizado em Ver como Markdown

Build an AI-powered code execution system using Sandbox SDK and Claude. Turn natural language questions into Python code, execute it securely, and return results.

Time to complete: 20 minutes

What you'll build

An API that accepts questions like "What's the 100th Fibonacci number?", uses Claude to generate Python code, executes it in an isolated sandbox, and returns the results.

Prerequisites

  1. Sign up for a Cloudflare account ↗.
  2. Install Node.js ↗.

Node.js version manager

Use a Node version manager like Volta ↗ or nvm ↗ to avoid permission issues and change Node.js versions. Wrangler, discussed later in this guide, requires a Node version of 16.17.0 or later.

You'll also need:

1. Create your project

Create a new Sandbox SDK project:


								
									
									npm
									 create cloudflare@latest -- ai-code-executor --template=cloudflare/sandbox-sdk/examples/minimal
								
							
cd ai-code-executor

2. Install dependencies

Install the Anthropic SDK:


								
									
									npm
									 i @anthropic-ai/sdk

3. Build your code executor

Replace the contents of src/index.ts:

import { getSandbox, type Sandbox } from '@cloudflare/sandbox';
import Anthropic from '@anthropic-ai/sdk';

export { Sandbox } from '@cloudflare/sandbox';

interface Env {
	Sandbox: DurableObjectNamespace<Sandbox>;
	ANTHROPIC_API_KEY: string;
}

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		if (request.method !== 'POST' || new URL(request.url).pathname !== '/execute') {
			return new Response('POST /execute with { "question": "your question" }');
		}

		try {
			const { question } = await request.json();

			if (!question) {
				return Response.json({ error: 'Question is required' }, { status: 400 });
			}

			// Use Claude to generate Python code
			const anthropic = new Anthropic({ apiKey: env.ANTHROPIC_API_KEY });
			const codeGeneration = await anthropic.messages.create({
				model: 'claude-sonnet-4-5',
				max_tokens: 1024,
				messages: [{
					role: 'user',
					content: `Generate Python code to answer: "${question}"

Requirements:
- Use only Python standard library
- Print the result using print()
- Keep code simple and safe

Return ONLY the code, no explanations.`
				}],
			});

			const generatedCode = codeGeneration.content[0]?.type === 'text'
				? codeGeneration.content[0].text
				: '';

			if (!generatedCode) {
				return Response.json({ error: 'Failed to generate code' }, { status: 500 });
			}

			// Strip markdown code fences if present
			const cleanCode = generatedCode
				.replace(/^```python?\n?/, '')
				.replace(/\n?```\s*$/, '')
				.trim();

			// Execute the code in a sandbox
			const sandbox = getSandbox(env.Sandbox, 'demo-user');
			await sandbox.writeFile('/tmp/code.py', cleanCode);
			const result = await sandbox.exec('python /tmp/code.py');

			return Response.json({
				success: result.success,
				question,
				code: generatedCode,
				output: result.stdout,
				error: result.stderr
			});

		} catch (error: any) {
			return Response.json(
				{ error: 'Internal server error', message: error.message },
				{ status: 500 }
			);
		}
	},
};

How it works:

  1. Receives a question via POST to /execute
  2. Uses Claude to generate Python code
  3. Writes code to /tmp/code.py in the sandbox
  4. Executes with sandbox.exec('python /tmp/code.py')
  5. Returns both the code and execution results

4. Set up local environment variables

Create a .dev.vars file in your project root for local development:

echo "ANTHROPIC_API_KEY=your_api_key_here" > .dev.vars

Replace your_api_key_here with your actual API key from the Anthropic Console ↗.

5. Test locally

Start the development server:

npm run dev

Test with curl:

curl -X POST http://localhost:8787/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "What is the 10th Fibonacci number?"}'

Response:

{
  "success": true,
  "question": "What is the 10th Fibonacci number?",
  "code": "def fibonacci(n):\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)\n\nprint(fibonacci(10))",
  "output": "55\n",
  "error": ""
}

6. Deploy

Deploy your Worker:

npx wrangler deploy

Then set your Anthropic API key as a production secret:

npx wrangler secret put ANTHROPIC_API_KEY

Paste your API key from the Anthropic Console ↗ when prompted.

7. Test your deployment

Try different questions:

# Factorial
curl -X POST https://ai-code-executor.YOUR_SUBDOMAIN.workers.dev/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "Calculate the factorial of 5"}'

# Statistics
curl -X POST https://ai-code-executor.YOUR_SUBDOMAIN.workers.dev/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "What is the mean of [10, 20, 30, 40, 50]?"}'

# String manipulation
curl -X POST https://ai-code-executor.YOUR_SUBDOMAIN.workers.dev/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "Reverse the string \"Hello World\""}'

What you built

You created an AI code execution system that:

  • Accepts natural language questions
  • Generates Python code with Claude
  • Executes code securely in isolated sandboxes
  • Returns results with error handling

Next steps