Drills: AI Agents & Tool Calling

import anthropic
client = anthropic.Anthropic()

resp = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=512,
    system="You are DocChat, a precise document assistant.",
    messages=[{"role": "user", "content": "Say hello in one line."}],
)
for block in resp.content:
    if block.type == "text":
        print(block.text)

Remember: content is a list of blocks, not a string. Always guard on block.type.

weather_tool = {
    "name": "get_weather",
    "description": (
        "Get the current weather for a city. Use this whenever the "
        "user asks about weather or temperature."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "City name, e.g. Dubai."},
        },
        "required": ["city"],
        "additionalProperties": False,
    },
}

tool_calls = [b for b in resp.content if b.type == "tool_use"]
if tool_calls:
    block = tool_calls[0]
    print(block.id)      # toolu_01A... — echo this back as tool_use_id
    print(block.name)    # get_weather
    print(block.input)   # {"city": "Dubai"} — already parsed, a dict

block.input is already a parsed dict — never raw-string-match the serialized JSON.

def agent(question, tools, run_tool):
    messages = [{"role": "user", "content": question}]

    for _ in range(5):                       # max-iteration guard
        resp = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=tools,
            messages=messages,
        )
        if resp.stop_reason == "end_turn":
            return next(b.text for b in resp.content if b.type == "text")

        messages.append({"role": "assistant", "content": resp.content})
        results = [
            {"type": "tool_result", "tool_use_id": b.id,
             "content": run_tool(b.name, b.input)}
            for b in resp.content if b.type == "tool_use"
        ]
        messages.append({"role": "user", "content": results})

    return "Hit the step limit."

Two non-negotiables: append resp.content before the results, and return all results in one user message.

import json

resp = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=256,
    messages=[{"role": "user",
               "content": "Ticket: Ada says the server is down NOW."}],
    output_config={"format": {
        "type": "json_schema",
        "schema": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "urgent": {"type": "boolean"},
            },
            "required": ["name", "urgent"],
            "additionalProperties": False,
        },
    }},
)
data = json.loads(next(b.text for b in resp.content if b.type == "text"))
print(data["name"], data["urgent"])   # Ada True

Don't prefill the assistant turn with { — that's a 400 on current models. output_config.format is the supported way.

import anthropic, ast, operator
client = anthropic.Anthropic()

TOOLS = [
    {"name": "search_documents",
     "description": "Search DocChat for relevant passages. Use for document questions.",
     "input_schema": {"type": "object",
        "properties": {"query": {"type": "string"}},
        "required": ["query"], "additionalProperties": False}},
    {"name": "calculator",
     "description": "Evaluate an arithmetic expression. Use for any math.",
     "input_schema": {"type": "object",
        "properties": {"expr": {"type": "string"}},
        "required": ["expr"], "additionalProperties": False}},
]

_OPS = {ast.Add: operator.add, ast.Sub: operator.sub,
        ast.Mult: operator.mul, ast.Div: operator.truediv}

def safe_calc(expr):
    def ev(node):
        if isinstance(node, ast.Constant): return node.value
        if isinstance(node, ast.BinOp): return _OPS[type(node.op)](ev(node.left), ev(node.right))
        raise ValueError("unsupported expression")
    return str(ev(ast.parse(expr, mode="eval").body))

def run_tool(name, args):
    if name == "search_documents":
        return "[office.pdf] The Dubai office seats 40 people."   # stub
    if name == "calculator":
        return safe_calc(args["expr"])
    return f"Unknown tool: {name}"

def agent(question, max_steps=6):
    messages = [{"role": "user", "content": question}]
    for _ in range(max_steps):
        resp = client.messages.create(
            model="claude-sonnet-4-6", max_tokens=1024,
            system="You are DocChat. Use tools, then answer grounded in results.",
            tools=TOOLS, messages=messages)
        if resp.stop_reason == "end_turn":
            return next(b.text for b in resp.content if b.type == "text")
        messages.append({"role": "assistant", "content": resp.content})
        messages.append({"role": "user", "content": [
            {"type": "tool_result", "tool_use_id": b.id,
             "content": run_tool(b.name, b.input)}
            for b in resp.content if b.type == "tool_use"]})
    return "Hit the step limit."

print(agent("How many seats in the office, and the cost at 1200 AED each?"))

The model searches first (40 seats), then calls the calculator (40 × 1200) — two tools, one question, all its own decision. Note the AST-based safe_calc: never eval() model-supplied strings.