Tool search tool

The tool search tool enables Claude to work with hundreds or thousands of tools by dynamically discovering and loading them on-demand. Instead of loading all tool definitions into the context window upfront, Claude searches your tool catalog (including tool names, descriptions, argument names, and argument descriptions) and loads only the tools it needs.

This approach solves two problems that compound quickly as tool libraries scale:

• Context bloat: Tool definitions eat into your context budget fast. A typical multi-server setup (GitHub, Slack, Sentry, Grafana, Splunk) can consume ~55k tokens in definitions before Claude does any actual work. Tool search typically reduces this by over 85%, loading only the 3–5 tools Claude actually needs for a given request.
• Tool selection accuracy: Claude's ability to correctly pick the right tool degrades significantly once you exceed 30–50 available tools. By surfacing a focused set of relevant tools on demand, tool search keeps selection accuracy high even across thousands of tools.

Although this is provided as a server-side tool, you can also implement your own client-side tool search functionality. See Custom tool search implementation for details.

You can also implement client-side tool search by returning tool_reference blocks from your own search implementation.

How tool search works

There are two tool search variants:

• Regex (tool_search_tool_regex_20251119): Claude constructs regex patterns to search for tools
• BM25 (tool_search_tool_bm25_20251119): Claude uses natural language queries to search for tools

When you enable the tool search tool:

1. You include a tool search tool (e.g., tool_search_tool_regex_20251119 or tool_search_tool_bm25_20251119) in your tools list
2. You provide all tool definitions with defer_loading: true for tools that shouldn't be loaded immediately
3. Claude sees only the tool search tool and any non-deferred tools initially
4. When Claude needs additional tools, it searches using a tool search tool
5. The API returns 3-5 most relevant tool_reference blocks
6. These references are automatically expanded into full tool definitions
7. Claude selects from the discovered tools and invokes them

This keeps your context window efficient while maintaining high tool selection accuracy.

Quick start

Here's a simple example with deferred tools:

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 2048,
        "messages": [
            {
                "role": "user",
                "content": "What is the weather in San Francisco?"
            }
        ],
        "tools": [
            {
                "type": "tool_search_tool_regex_20251119",
                "name": "tool_search_tool_regex"
            },
            {
                "name": "get_weather",
                "description": "Get the weather at a specific location",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string"},
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["location"]
                },
                "defer_loading": true
            },
            {
                "name": "search_files",
                "description": "Search through files in the workspace",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "query": {"type": "string"},
                        "file_types": {
                            "type": "array",
                            "items": {"type": "string"}
                        }
                    },
                    "required": ["query"]
                },
                "defer_loading": true
            }
        ]
    }'

Tool definition

The tool search tool has two variants:

{
  "type": "tool_search_tool_regex_20251119",
  "name": "tool_search_tool_regex"
}

{
  "type": "tool_search_tool_bm25_20251119",
  "name": "tool_search_tool_bm25"
}

Deferred tool loading

Mark tools for on-demand loading by adding defer_loading: true:

{
  "name": "get_weather",
  "description": "Get current weather for a location",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": { "type": "string" },
      "unit": { "type": "string", "enum": ["celsius", "fahrenheit"] }
    },
    "required": ["location"]
  },
  "defer_loading": true
}

Key points:

• Tools without defer_loading are loaded into context immediately
• Tools with defer_loading: true are only loaded when Claude discovers them via search
• The tool search tool itself should never have defer_loading: true
• Keep your 3-5 most frequently used tools as non-deferred for optimal performance

Both tool search variants (regex and bm25) search tool names, descriptions, argument names, and argument descriptions.

How deferral works internally: Deferred tools are not included in the system-prompt prefix. When the model discovers a deferred tool through tool search, the tool definition is appended inline as a tool_reference block in the conversation. The prefix is untouched, so prompt caching is preserved. The grammar for strict mode builds from the full toolset, so defer_loading and strict mode compose without grammar recompilation.

Response format

When Claude uses the tool search tool, the response includes new block types:

{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll search for tools to help with the weather information."
    },
    {
      "type": "server_tool_use",
      "id": "srvtoolu_01ABC123",
      "name": "tool_search_tool_regex",
      "input": {
        "query": "weather"
      }
    },
    {
      "type": "tool_search_tool_result",
      "tool_use_id": "srvtoolu_01ABC123",
      "content": {
        "type": "tool_search_tool_search_result",
        "tool_references": [{ "type": "tool_reference", "tool_name": "get_weather" }]
      }
    },
    {
      "type": "text",
      "text": "I found a weather tool. Let me get the weather for San Francisco."
    },
    {
      "type": "tool_use",
      "id": "toolu_01XYZ789",
      "name": "get_weather",
      "input": { "location": "San Francisco", "unit": "fahrenheit" }
    }
  ],
  "stop_reason": "tool_use"
}

Understanding the response

• server_tool_use: Indicates Claude is invoking the tool search tool
• tool_search_tool_result: Contains the search results with a nested tool_search_tool_search_result object
• tool_references: Array of tool_reference objects pointing to discovered tools
• tool_use: Claude invoking the discovered tool

The tool_reference blocks are automatically expanded into full tool definitions before being shown to Claude. You don't need to handle this expansion yourself. It happens automatically in the API as long as you provide all matching tool definitions in the tools parameter.

MCP integration

For configuring mcp_toolset with defer_loading, see MCP connector.

Custom tool search implementation

You can implement your own tool search logic (e.g., using embeddings or semantic search) by returning tool_reference blocks from a custom tool. When Claude calls your custom search tool, return a standard tool_result with tool_reference blocks in the content array:

{
  "type": "tool_result",
  "tool_use_id": "toolu_your_tool_id",
  "content": [{ "type": "tool_reference", "tool_name": "discovered_tool_name" }]
}

Every tool referenced must have a corresponding tool definition in the top-level tools parameter with defer_loading: true. This approach lets you use more sophisticated search algorithms while maintaining compatibility with the tool search system.

For a complete example using embeddings, see the tool search with embeddings cookbook.

Error handling

HTTP errors (400 status)

These errors prevent the request from being processed:

All tools deferred:

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "All tools have defer_loading set. At least one tool must be non-deferred."
  }
}

Missing tool definition:

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "Tool reference 'unknown_tool' has no corresponding tool definition"
  }
}

Tool result errors (200 status)

Errors during tool execution return a 200 response with error information in the body:

{
  "type": "tool_result",
  "tool_use_id": "srvtoolu_01ABC123",
  "content": {
    "type": "tool_search_tool_result_error",
    "error_code": "invalid_pattern"
  }
}

Error codes:

• too_many_requests: Rate limit exceeded for tool search operations
• invalid_pattern: Malformed regex pattern
• pattern_too_long: Pattern exceeds 200 character limit
• unavailable: Tool search service temporarily unavailable

Common mistakes

Prompt caching

For how defer_loading preserves prompt caching, see Tool use with prompt caching.

The system automatically expands tool_reference blocks throughout the entire conversation history, so Claude can reuse discovered tools in subsequent turns without re-searching.

Streaming

With streaming enabled, you'll receive tool search events as part of the stream:

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "server_tool_use", "id": "srvtoolu_xyz789", "name": "tool_search_tool_regex"}}

// Search query streamed
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "input_json_delta", "partial_json": "{\"query\":\"weather\"}"}}

// Pause while search executes

// Search results streamed
event: content_block_start
data: {"type": "content_block_start", "index": 2, "content_block": {"type": "tool_search_tool_result", "tool_use_id": "srvtoolu_xyz789", "content": {"type": "tool_search_tool_search_result", "tool_references": [{"type": "tool_reference", "tool_name": "get_weather"}]}}}

// Claude continues with discovered tools

Batch requests

You can include the tool search tool in the Messages Batches API. Tool search operations through the Messages Batches API are priced the same as those in regular Messages API requests.

Data retention

Server-side tool search (tool_search tool) indexes and stores tool catalog data (tool names, descriptions, and argument metadata) beyond the immediate API response; this catalog data is retained according to Anthropic's standard retention policy. Custom client-side tool search implementations that use the standard Messages API are fully ZDR-eligible.

For ZDR eligibility across all features, see API and data retention.

Limits and best practices

Limits

• Maximum tools: 10,000 tools in your catalog
• Search results: Returns 3-5 most relevant tools per search
• Pattern length: Maximum 200 characters for regex patterns
• Model support: Sonnet 4.0+, Opus 4.0+ only (no Haiku)

When to use tool search

Good use cases:

• 10+ tools available in your system
• Tool definitions consuming >10k tokens
• Experiencing tool selection accuracy issues with large tool sets
• Building MCP-powered systems with multiple servers (200+ tools)
• Tool library growing over time

When traditional tool calling might be better:

• Less than 10 tools total
• All tools are frequently used in every request
• Very small tool definitions (<100 tokens total)

Optimization tips

• Keep 3-5 most frequently used tools as non-deferred
• Write clear, descriptive tool names and descriptions
• Use consistent namespacing in tool names: prefix by service or resource (e.g., github_, slack_) so that search queries naturally surface the right tool group
• Use semantic keywords in descriptions that match how users describe tasks
• Add a system prompt section describing available tool categories: "You can search for tools to interact with Slack, GitHub, and Jira"
• Monitor which tools Claude discovers to refine descriptions

Usage

Tool search tool usage is tracked in the response usage object:

{
  "usage": {
    "input_tokens": 1024,
    "output_tokens": 256,
    "server_tool_use": {
      "tool_search_requests": 2
    }
  }
}

Next steps