AI Agents Fundamentals Basics

python -m venv .venv && source .venv/bin/activate
pip install openai pydantic
export OPENAI_API_KEY="sk-..."
# Optional: export OPENAI_BASE_URL="https://openrouter.ai/api/v1"

from openai import OpenAI
 
client = OpenAI()  # uses OPENAI_API_KEY; set base_url for gateways
 
resp = client.chat.completions.create(
    model="gpt-4o-mini",  # swap model id as needed; verify at build
    messages=[{"role": "user", "content": "What is 17 * 24?"}],
)
print(resp.choices[0].message.content)

from pydantic import BaseModel, Field
 
class MultiplyArgs(BaseModel):
    a: float = Field(description="First number")
    b: float = Field(description="Second number")
 
tools = [{
    "type": "function",
    "function": {
        "name": "multiply",
        "description": "Multiply two numbers exactly. Use for arithmetic.",
        "parameters": MultiplyArgs.model_json_schema(),
    },
}]

messages = [{"role": "user", "content": "What is 17 * 24? Use the tool."}]
resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools,
)
msg = resp.choices[0].message
print("content:", msg.content)
print("tool_calls:", msg.tool_calls)

import json
 
def multiply(a: float, b: float) -> float:
    return a * b
 
REGISTRY = {"multiply": (MultiplyArgs, multiply)}
 
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = REGISTRY[call.function.name][0].model_validate_json(call.function.arguments)
        result = REGISTRY[call.function.name][1](**args.model_dump())
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps({"result": result}),
        })
    final = client.chat.completions.create(model="gpt-4o-mini", messages=messages, tools=tools)
    print(final.choices[0].message.content)

def run_agent(user_text: str, max_turns: int = 5) -> str:
    messages = [{"role": "user", "content": user_text}]
    for _ in range(max_turns):
        resp = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages, tools=tools
        )
        msg = resp.choices[0].message
        if not msg.tool_calls:
            return msg.content or ""
        messages.append(msg)
        for call in msg.tool_calls:
            schema, fn = REGISTRY[call.function.name]
            args = schema.model_validate_json(call.function.arguments)
            out = fn(**args.model_dump())
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps({"result": out}),
            })
    return "stopped: max turns"
 
print(run_agent("Compute (17 * 24) + (3 * 9). Use tools for each product."))

print(run_agent("In one sentence, what is a tool call?"))
print(run_agent("What is 81 * 76?"))

def multiply(a: float, b: float) -> float:
    if a > 1_000_000:
        raise ValueError("a too large for this demo tool")
    return a * b
 
# Inside the loop, wrap execution:
try:
    out = fn(**args.model_dump())
    payload = {"result": out}
except Exception as e:
    payload = {"error": str(e)}

trace = []  # append dicts: turn, tool, args, result/error
 
# After each tool execution:
trace.append({
    "tool": call.function.name,
    "args": args.model_dump(),
    "observation": payload,
})
print(json.dumps(trace, indent=2))