Tool Use & The Model Context Protocol

The moment an LLM can call a function, it stops being a chatbot and starts being a system. Tool use is the foundation of every agent in this course — without it, the model can only talk; with it, the model can act. This chapter covers the production-grade tool-use APIs from Anthropic and OpenAI, the Model Context Protocol that's standardizing the integration layer, and the practical patterns (parallel tools, strict schemas, error handling) that separate a demo from a deployment.

The Tool-Use Mental Model

A tool is a function the model can request — never invoke directly. The model doesn't run code; it produces structured JSON saying "please run get_weather with location="Tokyo"." Your code runs the function, gets the answer, and feeds the result back into the next model turn. That round-trip is the entire mechanism.

Anthropic Tool Use API

Anthropic's tool use API takes a list of tool definitions, each a JSON Schema. The model returns content blocks of type text, tool_use, or both.

import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "get_weather",
    "description": "Get current weather for a location.",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City, country"},
            "unit": {"type": "string", "enum": ["c", "f"]},
        },
        "required": ["location"],
    },
}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
)

if response.stop_reason == "tool_use":
    for block in response.content:
        if block.type == "tool_use":
            result = execute_tool(block.name, block.input)
            # feed result back as the next user turn

Tool choice modes

The tool_choice parameter controls how aggressively the model uses tools:

Parallel tool calls

Claude 4.x emits multiple tool_use blocks in a single turn when the model judges them independent. Your runtime must execute them concurrently and return all tool_results before the next model turn:

import asyncio

async def run_tools(tool_uses):
    # Fire all tool calls concurrently
    coros = [execute_tool(t.name, t.input) for t in tool_uses]
    results = await asyncio.gather(*coros, return_exceptions=True)
    return [
        {"type": "tool_result",
         "tool_use_id": t.id,
         "content": str(r),
         "is_error": isinstance(r, Exception)}
        for t, r in zip(tool_uses, results)
    ]

OpenAI Function Calling

OpenAI's function calling API mirrors Anthropic's shape. Two key features to know:

• strict: true — guarantees the model's output conforms to your schema. Eliminates the "LLM returned invalid JSON" failure mode entirely. Introduced August 2024.
• parallel_tool_calls: bool — same parallel-tool behavior as Claude. Default true; set false if your tools have side effects that must serialize.
• Responses API (2025) — replaces Chat Completions for new agent code. Built-in tools (web_search, file_search, computer_use) require no setup.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find recent news about MCP adoption.",
    tools=[
        {"type": "web_search"},   # built-in
        {"type": "function",
         "function": {
             "name": "save_summary",
             "strict": True,        # schema-conformant
             "parameters": {"type": "object", "properties": {
                 "title": {"type": "string"},
                 "summary": {"type": "string"},
             }, "required": ["title", "summary"]}}],
)

Model Context Protocol (MCP) — The Tool-Use Standard

The biggest 2024–2026 development in tool use isn't a new model — it's MCP, an open protocol Anthropic released in November 2024 that's now the universal way to expose tools to LLMs. By mid-2025 every major IDE (VS Code Copilot, Cursor, Zed, JetBrains), every major agent framework, and ChatGPT itself supports MCP servers. The practical effect: you write a tool once and any agent in any stack can use it.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather-server")

@mcp.tool()
def get_weather(location: str, unit: str = "c") -> dict:
    """Get current weather for a location."""
    # your real implementation here
    return {"location": location, "temp": 22, "unit": unit}

if __name__ == "__main__":
    mcp.run()  # stdio transport — Claude Desktop / Code reads this

Once registered (in ~/.claude.json or any client's MCP config), the tool is automatically available to every agent in that client. Schema, types, and docs are inferred from the Python signature.

Designing Good Tools — Heuristics That Work

The model's tool-selection accuracy depends almost entirely on how you describe and shape your tools. From Anthropic's official guidance and accumulated production experience:

1. Descriptions are documentation for the model, not for you. Write what the tool does, when to use it, when not to use it, and what the output looks like. Models pay attention to all four.
2. Names should be verbs or noun-verbs. get_weather beats weather. send_email beats email.
3. Few broad tools beat many narrow ones. A single search(query, filters) outperforms search_users, search_orders, search_products as separate tools — fewer for the model to choose between.
4. Constrain inputs aggressively. enum for known values, pattern for regex-validated strings, minimum/maximum for numbers. Strict schemas keep the model from inventing.
5. Return structured output. JSON, never prose. The next model turn parses it; humans read the trace.
6. Surface errors as content, not exceptions. Return {"error": "rate_limited", "retry_after": 30} with is_error: true. The model can react to it; an exception kills the loop.

Error Handling — Where Most Agents Break

The single most common production agent failure isn't bad reasoning — it's a tool that errored, returned something unexpected, and the model couldn't recover. Three rules:

• Always return — never raise. A raised exception bubbles up and the loop dies. Catch the exception, format it as a tool result with is_error: true, and let the model decide whether to retry, fall back, or give up.
• Make errors actionable. {"error": "city_not_found", "suggestion": "Try a more specific name like 'Tokyo, Japan'"} teaches the model how to recover. {"error": "500"} teaches it nothing.
• Set per-tool timeouts. A 30-second tool can deadlock a 2-second agent. Wrap every tool call in asyncio.wait_for or equivalent.