Code Interpreter Patterns

import os
import re
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

# Initialize OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
e2b_api_key = os.getenv("E2B_API_KEY")

def extract_code(text):
    """
    Extracts Python code from markdown code blocks.
    If no blocks are found, returns the raw text (risky, but a fallback).
    """
    pattern = r"

match = re.search(pattern, text, re.DOTALL)

if match:

return match.group(1)

return text

print("Setup complete. Helper function ready.")

Why this matters: The LLM is a chat bot. It loves to chat. It will say "Here is your code:" before the code. We cannot execute "Here is your code:" in Python. This regex strips away the chatter and leaves only the executable logic.

Step 2: The "Brain" (Prompting for Code)

We need to tell the LLM that its job is not to answer the question directly, but to write code that answers the question.

Add this function to your file:

def generate_python_code(user_query):
    system_prompt = """
    You are an expert Python Data Analyst.
    Your goal is to solve the user's problem by writing Python code.
    
    RULES:
    1. Do NOT try to answer the question directly.
    2. Write a complete Python script that prints the answer to stdout.
    3. Use standard libraries or pandas/numpy.
    4. Wrap your code in 
python

"""

response = client.chat.completions.create(

model="gpt-4o", # Or gpt-3.5-turbo

messages=[

{"role": "system", "content": system_prompt},

{"role": "user", "content": user_query}

]

)

raw_content = response.choices[0].message.content

return extract_code(raw_content)

code = generate_python_code("Calculate the sum of the first 50 prime numbers.")

print("--- Generated Code ---")

print(code)

Step 3: The "Hands" (E2B Sandbox Execution)

Update your imports and add the execution logic:

from e2b_code_interpreter import Sandbox

def execute_in_sandbox(code_to_run):
    print("\n--- Executing in Sandbox ---")
    
    # We use 'with' to ensure the sandbox closes automatically
    with Sandbox(api_key=e2b_api_key) as sandbox:
        execution = sandbox.run_code(code_to_run)
        
        # Check for errors
        if execution.error:
            print(f"Error: {execution.error.name}: {execution.error.value}")
            return None
        
        # Return the standard output (logs/prints)
        return execution.logs

# Let's put it together
query = "Calculate the sum of the first 50 prime numbers."
generated_code = generate_python_code(query)
results = execute_in_sandbox(generated_code)

print("\n--- Final Answer ---")
for log in results.stdout:
    print(log)

Step 4: Adding Data (The CSV Analyst)

Calculating primes is fun, but the real power is data analysis. We need to create a dummy CSV file, upload it to the sandbox, and have the agent analyze it.

Let's create a scenario: Sales data.

# Create a dummy CSV file locally
csv_content = """Date,Product,Price,Units_Sold
2023-01-01,Widget A,10.00,5
2023-01-02,Widget B,20.00,2
2023-01-03,Widget A,10.00,10
2023-01-04,Widget C,50.00,1
2023-01-05,Widget A,10.00,3
"""

with open("sales_data.csv", "w") as f:
    f.write(csv_content)

def analyze_data_file(user_query, file_path):
    # 1. Read the file to get column names (so the LLM knows what to write)
    # In a real app, we might just pass the header row to the LLM
    with open(file_path, "r") as f:
        header = f.readline()
    
    # 2. Update prompt to include context about the file
    prompt_with_context = f"""
    You have a CSV file named '{file_path}' loaded in the environment.
    The columns are: {header}
    
    Write pandas code to answer: {user_query}
    """
    
    # 3. Generate Code
    print("Generating code...")
    code = generate_python_code(prompt_with_context)
    
    # 4. Execute in Sandbox WITH the file
    print("Uploading file and executing...")
    with Sandbox(api_key=e2b_api_key) as sandbox:
        # Upload the file to the cloud sandbox
        with open(file_path, "rb") as f:
            sandbox.files.write(file_path, f)
            
        execution = sandbox.run_code(code)
        
        if execution.error:
            print("Execution failed:", execution.error)
        else:
            print("\n--- Answer ---")
            print(execution.logs.stdout)

# Run the full agent
analyze_data_file("What was the total revenue for Widget A?", "sales_data.csv")

Now You Try

You have a working Code Interpreter. Now, extend its capabilities.

Challenge Project: The Visualization Agent

Text answers are great, but data analysts produce charts. Your challenge is to make the agent generate a graph.

* Update the system prompt to tell the LLM: "If asked for a chart, save it as 'output.png'."