Tools + your first agent

b1 gave you the loop and the four levers. Tonight turns on the first lever: tools. You will read one tool definition the way the model reads it, meet the Daybreak toolbox you may have built in the MCP course, then write the loop yourself - no framework, no SDK magic - so that every framework you touch afterwards is just this loop wearing a coat.

A tool definition has three parts: a name, a description, and a JSON Schema for its input. Here is the part almost everyone gets backwards: the model never sees your Python. It sees the description. Anthropic's essay closes on exactly this point - appendix 2 is about crafting the agent-computer interface (ACI): prompt-engineer your tool docs and test them, the same way you would craft a prompt. A vague description gives you a confused agent no system prompt can rescue.

This course does not invent a toolbox - it inherits one. The MCP course's Daybreak server (server.py in this repo's project folder) ships three tools, two resources, and one prompt over the same SQLite database the SQL course used. That server is this agent's hands for the rest of the track.

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

params = StdioServerParameters(command="uv", args=["run", "server.py"])
async with stdio_client(params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        tools = await session.list_tools()   # query_sales, top_products, subscription_status
        result = await session.call_tool("query_sales", {"month": "2026-03"})

import sqlite3

def query_sales(month: str) -> str:
    """Order count, refunds, and completed revenue for one month (YYYY-MM)."""
    con = sqlite3.connect("daybreak.db")
    try:
        rows = con.execute(
            "SELECT status, COUNT(DISTINCT o.order_id),"
            "       COALESCE(SUM(oi.quantity * oi.unit_price), 0)"
            "  FROM orders o JOIN order_items oi ON oi.order_id = o.order_id"
            " WHERE substr(o.order_date, 1, 7) = ? GROUP BY status",
            (month,),
        ).fetchall()
    finally:
        con.close()
    ...  # format exactly like the MCP server does

TOOL_FUNCTIONS = {"query_sales": query_sales,
                  "top_products": top_products,
                  "subscription_status": subscription_status}

Here is the entire agent, no framework. One while-style loop: call the model with tools attached; if it stops because it wants a tool (stop_reason == "tool_use"), run the tool, append the result, go around again; otherwise it answered - break. The b1 exit conditions are all here: a final answer, no more tool calls, an error, or the max_turns guard.

import anthropic

client = anthropic.Anthropic()

TOOLS = [{
    "name": "query_sales",
    "description": ("Order count, refunds, and completed revenue "
                    "for one month (YYYY-MM)."),
    "input_schema": {
        "type": "object",
        "properties": {
            "month": {"type": "string",
                      "description": "Month as YYYY-MM, e.g. 2026-03"},
        },
        "required": ["month"],
    },
}]

def run_agent(goal: str, max_turns: int = 10) -> str:
    messages = [{"role": "user", "content": goal}]
    for _ in range(max_turns):                      # exit 4: max turns
        response = client.messages.create(
            model="claude-opus-5",
            max_tokens=1024,
            tools=TOOLS,
            messages=messages,
        )
        if response.stop_reason == "tool_use":      # model wants a tool run
            messages.append({"role": "assistant", "content": response.content})
            results = []
            for block in response.content:
                if block.type == "tool_use":
                    output = TOOL_FUNCTIONS[block.name](**block.input)
                    results.append({"type": "tool_result",
                                    "tool_use_id": block.id,
                                    "content": output})
            messages.append({"role": "user", "content": results})
            continue                                # observe, then loop
        return response.content[0].text             # exits 1-2: done
    return "Stopped: max_turns reached."

print(run_agent("What was March 2026 revenue?"))
# -> calls query_sales("2026-03") -> "$150.00 completed, 1 refunded"

import ollama

messages = [{"role": "user", "content": "What was March 2026 revenue?"}]
for _ in range(10):
    response = ollama.chat(model="qwen3", messages=messages,
                           tools=[query_sales])   # functions as tools
    messages.append(response.message)
    if not response.message.tool_calls:
        print(response.message.content)           # final answer
        break
    for call in response.message.tool_calls:
        output = TOOL_FUNCTIONS[call.function.name](**call.function.arguments)
        messages.append({"role": "tool", "tool_name": call.function.name,
                         "content": str(output)})

This is the loop you just wrote, running the b1 question over Daybreak's real data. This time you know the machinery - so predict each step before you click Next: what will the model do, which tool, which argument, what comes back?

The scorecard from b1, with the lever you built tonight switched on. You just unlocked rung 1: 5/12 - up from 1/12 with everything off. Lookups live. But do not skip the fine print on task 12.

• Run your loop against three questions: "What was March 2026 revenue?", "What are our top products?", and "How many active subscriptions do we have?" - one tool each. Watch the stop_reason on every turn.
• Write one NEW tool schema for Daybreak, description-first: draft the description and schema before any Python, then check it against the three ACI habits from Part 1. (Candidates: order lookup by customer, revenue by product.)
• Break the loop on purpose: remove the max_turns guard, then ask an impossible task ("find the order from 2019" - the data starts in 2026) and watch it never exit. Put the guard back. You now believe in exit conditions.

Certificates, videos, and graded assessments stay on the official sites (linked each session). This page covers: