Functions

An LLM on its own can only produce text, it can't read a file, run code, or change anything. To build an actual agent (something that takes action, not just talks), you first need real Python functions it can eventually be given access to. This lesson writes three: reading a file, writing a file, and running arbitrary Python code.

Reading and writing files

def read_file(path):
    with open(path, 'r') as f:
        return f.read()

def write_file(path, content):
    with open(path, 'w') as f:
        f.write(content)
    return f'Wrote {len(content)} characters to {path}'

write_file('notes.txt', 'Remember to fix the bug in calculate_total().')
print(read_file('notes.txt'))

These are the two most basic actions any coding agent needs: seeing what's currently in a file, and changing it. Nothing fancy yet, just Python's built-in open().

Running arbitrary Python code

An agent that can fix bugs needs to actually execute code to test whether a fix works, not just read and write text:

import io
import contextlib

def run_python(code):
    output = io.StringIO()
    try:
        with contextlib.redirect_stdout(output):
            exec(code, {})
        return output.getvalue() or '(no output)'
    except Exception as e:
        return f'Error: {e}'

print(run_python('print(2 + 2)'))
print(run_python('print(1 / 0)'))

• exec(code, {}) runs a string of Python code as if it were a script. Passing {} as its globals dict gives it a fresh, empty namespace each call, so one run_python call can't accidentally see variables left over from a previous one.
• contextlib.redirect_stdout(output) temporarily redirects anything the code print()s into an in-memory buffer (io.StringIO()) instead of your real terminal, so run_python can capture and return it as a string, exactly what's needed to hand the result back to an LLM as text.
• The try/except is deliberate: if the executed code raises an error (like the division by zero above), run_python returns a description of the error as its result, instead of crashing your whole program. An agent needs to see its mistakes as feedback ("that failed because...") to correct course, not have the entire session die.