	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Large Language Models > Claude Tool Use - Function Calling

Claude Tool Use - Function Calling

Author: Venkata Sudhakar

Claude tool use lets you give the model access to your own business functions - stock checkers, order systems, customer databases, pricing APIs - so it can look up real data before answering rather than guessing. You define each tool as a JSON schema describing its name, purpose, and parameters. Claude decides when to call a tool based on the conversation, returns a structured tool_use block with the arguments it wants to pass, your code executes the function and sends the result back, and Claude incorporates the real data into its final answer. This is the foundation of any Claude-powered business agent.

The tool use flow has four steps: send messages with tools defined, receive a response where stop_reason is "tool_use", execute the requested tool locally, then send the tool result back in a new message with role "user" and type "tool_result". Claude then continues the conversation with the real data. A single response can request multiple tool calls simultaneously - Claude is smart enough to call stock_check for several items at once rather than one at a time, reducing round trips.

The below example shows a retail assistant that can check stock levels and place orders. A customer asks about buying laptops for their office and Claude autonomously checks availability before recommending.

import anthropic
import json

client = anthropic.Anthropic(api_key="your-api-key")

# Simulated business functions (in production: real DB/API calls)
def check_stock(product_name: str, warehouse: str = "main") -> dict:
    inventory = {
        "Dell XPS 15":        {"main": 8,  "north": 3},
        "MacBook Pro M3":     {"main": 5,  "north": 0},
        "Lenovo ThinkPad X1": {"main": 12, "north": 7},
        "HP Spectre x360":    {"main": 2,  "north": 1},
    }
    product = inventory.get(product_name, {})
    qty = product.get(warehouse, 0)
    return {"product": product_name, "warehouse": warehouse,
            "quantity": qty, "available": qty > 0}

def place_order(product_name: str, quantity: int, customer_id: str) -> dict:
    if quantity > 20:
        return {"success": False, "reason": "Bulk orders over 20 units require procurement approval"}
    return {"success": True, "order_id": "ORD-" + customer_id[-4:] + "-7821",
            "product": product_name, "quantity": quantity,
            "estimated_delivery": "3-5 business days"}

# Tool definitions - Claude reads these to know what it can do
tools = [
    {
        "name": "check_stock",
        "description": "Check how many units of a product are available in our warehouse. "
                       "Use this before recommending a product to confirm it is in stock.",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_name": {"type": "string", "description": "Exact product name"},
                "warehouse":    {"type": "string", "enum": ["main", "north"],
                                 "description": "Which warehouse to check"}
            },
            "required": ["product_name"]
        }
    },
    {
        "name": "place_order",
        "description": "Place a purchase order for a customer. Only call this if the customer explicitly confirms they want to buy.",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_name": {"type": "string"},
                "quantity":     {"type": "integer", "description": "Number of units"},
                "customer_id":  {"type": "string",  "description": "Customer account ID"}
            },
            "required": ["product_name", "quantity", "customer_id"]
        }
    }
]

Running the tool use loop with a real customer conversation,

def run_agent(user_message: str, customer_id: str = "CUST-4491") -> str:
    messages = [{"role": "user", "content": user_message}]
    system = ("You are a helpful sales assistant for LaptopWorld. "
              "Always check stock before recommending a product. "
              "Be specific about availability.")

while True:
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=500,
            system=system,
            tools=tools,
            messages=messages
        )

# Add assistant response to conversation history
        messages.append({"role": "assistant", "content": response.content})

if response.stop_reason == "end_turn":
            # Claude has a final text answer - extract and return it
            return next(b.text for b in response.content if hasattr(b, "text"))

if response.stop_reason == "tool_use":
            # Claude wants to call tools - execute each one
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  [Tool call] {block.name}({block.input})")
                    if block.name == "check_stock":
                        result = check_stock(**block.input)
                    elif block.name == "place_order":
                        inp = dict(block.input)
                        inp["customer_id"] = customer_id
                        result = place_order(**inp)
                    else:
                        result = {"error": "unknown tool"}
                    print(f"  [Tool result] {result}")
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": json.dumps(result)
                    })
            messages.append({"role": "user", "content": tool_results})

print("Customer: I need 6 Dell XPS 15 laptops for my office team. Are they available?")
print()
answer = run_agent("I need 6 Dell XPS 15 laptops for my office team. Are they available?")
print("Claude:", answer)

It gives the following output showing the tool call loop,

Customer: I need 6 Dell XPS 15 laptops for my office team. Are they available?

  [Tool call] check_stock({"product_name": "Dell XPS 15", "warehouse": "main"})
  [Tool result] {"product": "Dell XPS 15", "warehouse": "main", "quantity": 8, "available": True}

Claude: Great news! We have 8 Dell XPS 15 units in stock at our main warehouse,
so we can fulfil your order of 6 units comfortably. Would you like me to go
ahead and place the order? If so, I can confirm delivery in 3-5 business days.

# Claude checked stock BEFORE answering - grounded in real data, not a guess
# If you say "yes please order them", Claude calls place_order next

Tool design tips: write clear tool descriptions because Claude reads them to decide when and whether to call each tool. Include "only call this if..." phrases for consequential tools like place_order or send_email to prevent accidental execution. Define required vs optional parameters carefully - Claude will always provide required fields but may omit optional ones. For tools that modify data, log every tool call and result in your database before returning the result to Claude so you have a full audit trail of what the agent did and why.

Send your comments, suggestions or queries regarding this site to [email protected].