⬡ API & SDK/2026-03-30Advanced

Building a Search-Augmented AI Assistant with Claude API: Web Search × Dynamic Filtering × Citations

Learn how to combine Claude API's Web Search Tool, Dynamic Filtering, and Citations API to build a production-grade search-augmented AI assistant that returns accurate, source-backed answers.

web-search⁴citationsdynamic-filteringproduction¹¹¹ api³⁹ code-execution³ rag⁴

✦ Premium Article

Why Search-Augmented AI Matters

As large language model (LLM) adoption scales up in production systems, information freshness and answer accuracy remain the two most critical challenges. In March 2026, Anthropic promoted the Web Search Tool and Programmatic Tool Calling to general availability (GA) and introduced Dynamic Filtering — a powerful feature that uses code execution to filter search results before they enter the context window.

This guide covers how to combine Web Search Tool, Dynamic Filtering, and Citations API to build a search-augmented AI assistant that returns accurate, source-backed answers in production. We'll walk through architecture design, complete code implementation, cost optimization strategies, and resilient error handling patterns.

While traditional RAG (Retrieval-Augmented Generation) requires maintaining your own vector database, the Web Search Tool lets you use the entire internet as your knowledge base. By layering Dynamic Filtering on top, you eliminate noise from search results, optimize token consumption, and achieve higher-quality answers.

For a broader take on search-augmented systems, see Building an Autonomous Research Agent with Claude API.

Architecture Overview — Integrating Three APIs

The search-augmented AI assistant architecture consists of three layers.

Search Layer (Web Search Tool): Executes real-time web searches based on user queries and collects relevant sources. The web_search_20260209 version supports domain filtering and user location settings.

Filtering Layer (Dynamic Filtering + Code Execution): Programmatically filters search results using a sandboxed code execution environment, removing irrelevant results before they consume context window tokens. This layer is the key to simultaneously improving both token efficiency and answer accuracy.

Answer Generation Layer (Citations API): Generates answers based on filtered information and automatically attaches source citations to each claim.

// Conceptual architecture code
import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
// Basic search-augmented assistant configuration
async function searchAugmentedAssistant(userQuery: string) {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 8096,
    tools: [
      {
        type: "web_search_20260209",
        name: "web_search",
        // Dynamic Filtering: filter search results via code execution
        dynamic_filtering: { enabled: true },
        // Domain restrictions (optional)
        allowed_domains: ["docs.anthropic.com", "github.com"],
      },
    ],
    // Enable Citations
    citations: { enabled: true },
    messages: [
      {
        role: "user",
        content: userQuery,
      },
    ],
  });
 
  return response;
}

This design creates an end-to-end pipeline: user query → web search → dynamic filtering → cited answer generation.

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦A design that cuts input tokens 40–60% with Dynamic Filtering while improving answer accuracy

✦An implementation that scores overall reliability from citation density, unique sources, and trusted-domain ratio

✦A multi-layer fallback that degrades from filtered search to basic search to model-only knowledge

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Web Search Tool Production Configuration — GA Version Parameter Reference

The Web Search Tool graduated from beta to general availability (GA) in March 2026, removing the need for beta headers. Here's how to configure it for maximum effectiveness in production.

Basic Configuration

// Production Web Search Tool configuration
const tools = [
  {
    type: "web_search_20260209",
    name: "web_search",
    // User location for localized results
    user_location: {
      type: "approximate",
      country: "US",
      region: "California",
    },
    // Allowed domains (optional: restrict to trusted sources)
    allowed_domains: [
      "docs.anthropic.com",
      "platform.claude.com",
      "github.com/anthropics",
    ],
    // Blocked domains (optional: exclude low-quality sources)
    blocked_domains: ["spam-site.example.com"],
  },
];

Enabling Dynamic Filtering

Dynamic Filtering allows Claude to use a sandboxed code execution environment to programmatically filter search results. This removes noise before it enters the context window, achieving both token savings and improved answer accuracy simultaneously.

// Configuration with Dynamic Filtering enabled
const toolsWithFiltering = [
  {
    type: "web_search_20260209",
    name: "web_search",
    dynamic_filtering: {
      enabled: true,
    },
    user_location: {
      type: "approximate",
      country: "US",
    },
  },
];

When Dynamic Filtering is enabled, Claude internally executes code in a sandbox environment to perform relevance scoring and deduplication of search results. Crucially, code execution is free when combined with Web Search — a significant cost advantage.

Domain Strategy Design

In production, your domain strategy should align with your use case.

Technical documentation search: Restrict to official documentation sites to eliminate outdated information and community misinformation.

News collection: Allowlist news sites while excluding social media and forums.

General search: Skip domain restrictions and let Dynamic Filtering assess result quality through code execution.

// Domain strategies by use case
const domainStrategies = {
  // Technical documentation
  techDocs: {
    allowed_domains: [
      "docs.anthropic.com",
      "platform.claude.com",
      "developer.mozilla.org",
      "nodejs.org",
    ],
  },
  // News collection
  news: {
    allowed_domains: [
      "www.anthropic.com",
      "techcrunch.com",
      "theverge.com",
    ],
    blocked_domains: ["reddit.com", "twitter.com"],
  },
  // General (delegate to Dynamic Filtering)
  general: {
    dynamic_filtering: { enabled: true },
    // No domain restrictions
  },
};

Dynamic Filtering in Practice — Maximizing Search Accuracy with Code Execution

Dynamic Filtering is one of the most powerful features of the Web Search Tool. Claude automatically executes code against search results to remove irrelevant items before they enter the context window.

How It Works

Claude executes a web search and retrieves multiple results
JavaScript/Python code is automatically executed in a sandbox
Each result is scored for relevance, reliability, and freshness
Low-scoring results are filtered out, keeping only top results
The answer is generated from filtered results only

Custom Filtering Logic

For more granular control, you can use Programmatic Tool Calling to customize filtering logic.

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
async function advancedSearchWithFiltering(query: string) {
  // Step 1: Execute Web Search
  const searchResponse = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 4096,
    tools: [
      {
        type: "web_search_20260209",
        name: "web_search",
        dynamic_filtering: { enabled: true },
      },
    ],
    messages: [
      {
        role: "user",
        content: `Search for the latest information on: ${query}`,
      },
    ],
  });
 
  // Step 2: Extract source information from results
  const sources = extractSources(searchResponse);
 
  // Step 3: Apply custom filtering
  const filteredSources = sources.filter((source) => {
    // Prioritize articles from the last 24 hours
    const isRecent =
      Date.now() - new Date(source.publishedDate).getTime() <
      24 * 60 * 60 * 1000;
    // Reliability score threshold
    const isReliable = source.reliabilityScore > 0.7;
    return isRecent || isReliable;
  });
 
  // Step 4: Generate answer with filtered sources + Citations
  const finalResponse = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 8096,
    citations: { enabled: true },
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: `Based on the following sources, answer "${query}". Always cite your sources.`,
          },
          // Pass filtered sources as documents
          ...filteredSources.map((source) => ({
            type: "document" as const,
            source: {
              type: "url" as const,
              url: source.url,
            },
            title: source.title,
          })),
        ],
      },
    ],
  });
 
  return finalResponse;
}
 
// Source extraction helper
function extractSources(response: Anthropic.Message) {
  const sources: Array<{
    url: string;
    title: string;
    publishedDate: string;
    reliabilityScore: number;
  }> = [];
 
  for (const block of response.content) {
    if (block.type === "web_search_tool_result") {
      for (const result of block.content) {
        if (result.type === "web_search_result") {
          sources.push({
            url: result.url,
            title: result.title,
            publishedDate: result.page_age || new Date().toISOString(),
            reliabilityScore: calculateReliability(result.url),
          });
        }
      }
    }
  }
 
  return sources;
}
 
// Domain-based reliability scoring
function calculateReliability(url: string): number {
  const trustedDomains: Record<string, number> = {
    "docs.anthropic.com": 1.0,
    "platform.claude.com": 1.0,
    "www.anthropic.com": 0.95,
    "github.com": 0.9,
    "developer.mozilla.org": 0.9,
  };
 
  for (const [domain, score] of Object.entries(trustedDomains)) {
    if (url.includes(domain)) return score;
  }
  return 0.5; // Default score
}

Measuring Filtering Effectiveness

To quantitatively assess Dynamic Filtering's impact, track these metrics.

// Filtering effectiveness metrics
interface FilteringMetrics {
  totalSearchResults: number;
  filteredResults: number;
  tokensBeforeFiltering: number;
  tokensAfterFiltering: number;
  filteringRatio: number;
  tokenSavings: number;
}
 
function measureFilteringEffect(
  before: number,
  after: number
): FilteringMetrics {
  return {
    totalSearchResults: before,
    filteredResults: after,
    tokensBeforeFiltering: before * 500, // ~500 tokens per result
    tokensAfterFiltering: after * 500,
    filteringRatio: 1 - after / before,
    tokenSavings: 1 - after / before,
  };
}
 
// Expected results:
// - Filtering ratio: 40-60% (removing over half of irrelevant results)
// - Token savings: 40-60% (significant input token cost reduction)
// - Answer accuracy: 15-25% improvement (less noise = less confusion)

Citations API Integration — Ensuring Trustworthy Answers with Source Attribution

The Citations feature structurally embeds source information into Claude's answers. It's a powerful tool against hallucination and essential for any search-augmented assistant.

For grounding answers on your own knowledge base, see Grounding Claude on Your Own Knowledge Base with search_result Blocks. Here we focus on advanced production patterns.

Enabling Citations and Parsing Responses

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
async function searchWithCitations(query: string) {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 8096,
    tools: [
      {
        type: "web_search_20260209",
        name: "web_search",
        dynamic_filtering: { enabled: true },
      },
    ],
    // Enable Citations
    citations: { enabled: true },
    messages: [
      {
        role: "user",
        content: query,
      },
    ],
  });
 
  // Extract structured citation information
  const result = parseResponseWithCitations(response);
  return result;
}
 
interface CitedContent {
  text: string;
  citations: Array<{
    sourceUrl: string;
    sourceTitle: string;
    citedText: string;
    startIndex: number;
    endIndex: number;
  }>;
}
 
function parseResponseWithCitations(
  response: Anthropic.Message
): CitedContent {
  const result: CitedContent = { text: "", citations: [] };
 
  for (const block of response.content) {
    if (block.type === "text") {
      if ("citations" in block && Array.isArray(block.citations)) {
        for (const citation of block.citations) {
          if (citation.type === "web_search_result_location") {
            result.citations.push({
              sourceUrl: citation.url,
              sourceTitle: citation.title || "",
              citedText: citation.cited_text || "",
              startIndex: citation.start_char_index,
              endIndex: citation.end_char_index,
            });
          }
        }
      }
      result.text += block.text;
    }
  }
 
  return result;
}

Citation Reliability Scoring

To quantify answer trustworthiness, build a system that measures citation density and quality.

interface AnswerReliability {
  citationDensity: number;
  uniqueSources: number;
  trustedSourceRatio: number;
  overallScore: number;
}
 
function assessAnswerReliability(
  cited: CitedContent
): AnswerReliability {
  const sentences = cited.text.split(/[.!?]/).filter(Boolean);
  const uniqueUrls = new Set(cited.citations.map((c) => c.sourceUrl));
  const trustedCount = cited.citations.filter((c) =>
    isTrustedDomain(c.sourceUrl)
  ).length;
 
  const citationDensity =
    sentences.length > 0 ? cited.citations.length / sentences.length : 0;
  const trustedRatio =
    cited.citations.length > 0
      ? trustedCount / cited.citations.length
      : 0;
 
  return {
    citationDensity,
    uniqueSources: uniqueUrls.size,
    trustedSourceRatio: trustedRatio,
    overallScore:
      citationDensity * 0.3 +
      Math.min(uniqueUrls.size / 5, 1) * 0.3 +
      trustedRatio * 0.4,
  };
}
 
function isTrustedDomain(url: string): boolean {
  const trusted = [
    "anthropic.com",
    "platform.claude.com",
    "github.com",
    "developer.mozilla.org",
    "nodejs.org",
    "typescriptlang.org",
  ];
  return trusted.some((domain) => url.includes(domain));
}
 
// Usage:
// const reliability = assessAnswerReliability(citedContent);
// if (reliability.overallScore < 0.5) {
//   console.warn("Low reliability — triggering additional search");
// }

Production Architecture — Complete Implementation

Let's bring everything together into a production-ready search-augmented AI assistant.

End-to-End Implementation

import Anthropic from "@anthropic-ai/sdk";
 
// --- Type Definitions ---
interface SearchAssistantConfig {
  model: string;
  maxTokens: number;
  systemPrompt: string;
  domainStrategy: "techDocs" | "news" | "general";
  reliabilityThreshold: number;
  maxRetries: number;
}
 
interface AssistantResponse {
  answer: string;
  citations: Array<{
    url: string;
    title: string;
    citedText: string;
  }>;
  reliability: {
    score: number;
    uniqueSources: number;
  };
  usage: {
    inputTokens: number;
    outputTokens: number;
    searchQueries: number;
  };
}
 
// --- Main Class ---
class SearchAugmentedAssistant {
  private client: Anthropic;
  private config: SearchAssistantConfig;
 
  constructor(config: Partial<SearchAssistantConfig> = {}) {
    this.client = new Anthropic();
    this.config = {
      model: "claude-sonnet-4-6",
      maxTokens: 8096,
      systemPrompt: `You are an AI assistant that provides accurate, up-to-date information.
Always cite your sources. Mark uncertain information with "reportedly" or "it appears that".
Prefix information not from search results with "Based on general knowledge".`,
      domainStrategy: "general",
      reliabilityThreshold: 0.5,
      maxRetries: 2,
      ...config,
    };
  }
 
  async answer(query: string): Promise<AssistantResponse> {
    let attempt = 0;
    let lastError: Error | null = null;
 
    while (attempt <= this.config.maxRetries) {
      try {
        const response = await this.executeSearch(query);
        const parsed = this.parseResponse(response);
 
        // Reliability check
        if (
          parsed.reliability.score < this.config.reliabilityThreshold &&
          attempt < this.config.maxRetries
        ) {
          console.log(
            `Reliability ${parsed.reliability.score} below threshold, retrying...`
          );
          attempt++;
          continue;
        }
 
        return parsed;
      } catch (error) {
        lastError = error as Error;
        attempt++;
 
        if (attempt <= this.config.maxRetries) {
          // Exponential backoff
          await new Promise((r) =>
            setTimeout(r, Math.pow(2, attempt) * 1000)
          );
        }
      }
    }
 
    throw new Error(
      `Search failed after ${this.config.maxRetries} retries: ${lastError?.message}`
    );
  }
 
  private async executeSearch(
    query: string
  ): Promise<Anthropic.Message> {
    return await this.client.messages.create({
      model: this.config.model,
      max_tokens: this.config.maxTokens,
      system: this.config.systemPrompt,
      tools: [
        {
          type: "web_search_20260209",
          name: "web_search",
          dynamic_filtering: { enabled: true },
          user_location: {
            type: "approximate",
            country: "US",
          },
        },
      ],
      citations: { enabled: true },
      messages: [
        {
          role: "user",
          content: query,
        },
      ],
    });
  }
 
  private parseResponse(
    response: Anthropic.Message
  ): AssistantResponse {
    let answerText = "";
    const citations: AssistantResponse["citations"] = [];
    let searchQueries = 0;
 
    for (const block of response.content) {
      if (block.type === "text") {
        answerText += block.text;
        if ("citations" in block && Array.isArray(block.citations)) {
          for (const c of block.citations) {
            if (c.type === "web_search_result_location") {
              citations.push({
                url: c.url,
                title: c.title || "",
                citedText: c.cited_text || "",
              });
            }
          }
        }
      }
      if (block.type === "server_tool_use" && block.name === "web_search") {
        searchQueries++;
      }
    }
 
    const uniqueSources = new Set(citations.map((c) => c.url)).size;
    const trustedCount = citations.filter((c) =>
      isTrustedDomain(c.url)
    ).length;
    const score =
      citations.length > 0
        ? (Math.min(uniqueSources / 5, 1) * 0.5 +
            (trustedCount / citations.length) * 0.5)
        : 0;
 
    return {
      answer: answerText,
      citations,
      reliability: { score, uniqueSources },
      usage: {
        inputTokens: response.usage.input_tokens,
        outputTokens: response.usage.output_tokens,
        searchQueries,
      },
    };
  }
}
 
function isTrustedDomain(url: string): boolean {
  const trusted = [
    "anthropic.com",
    "platform.claude.com",
    "github.com",
  ];
  return trusted.some((d) => url.includes(d));
}
 
// --- Usage Example ---
async function main() {
  const assistant = new SearchAugmentedAssistant({
    model: "claude-sonnet-4-6",
    reliabilityThreshold: 0.4,
  });
 
  const result = await assistant.answer(
    "What are the latest Claude API pricing changes and cost optimization best practices?"
  );
 
  console.log("=== Answer ===");
  console.log(result.answer);
  console.log("\n=== Citations ===");
  result.citations.forEach((c, i) => {
    console.log(`[${i + 1}] ${c.title}: ${c.url}`);
  });
  console.log("\n=== Metrics ===");
  console.log(`Reliability score: ${result.reliability.score.toFixed(2)}`);
  console.log(`Unique sources: ${result.reliability.uniqueSources}`);
  console.log(`Input tokens: ${result.usage.inputTokens}`);
  console.log(`Output tokens: ${result.usage.outputTokens}`);
  console.log(`Search queries: ${result.usage.searchQueries}`);
}
 
main().catch(console.error);
 
// Expected output:
// === Answer ===
// Claude API pricing as of March 2026... (detailed answer with citations)
// === Citations ===
// [1] Pricing - Claude API Docs: https://platform.claude.com/docs/...
// === Metrics ===
// Reliability score: 0.75
// Unique sources: 4
// Input tokens: 3200
// Output tokens: 1800
// Search queries: 2

Cost Optimization Strategies — Maximizing ROI for Search-Augmented Apps

Search-augmented assistants incur web search costs on top of standard API charges. Here's how to minimize costs while maintaining quality.

Understanding the Cost Structure

Search cost: A fixed fee per search query. Claude may execute multiple searches per request, so use the max_uses parameter to set an upper limit.

Code execution cost: Dynamic Filtering code execution is free when combined with Web Search — a major cost advantage.

Token cost: Search results count as context window tokens. Dynamic Filtering directly reduces token costs by eliminating irrelevant results.

Cost Optimization Implementation

// Cost-optimized configuration
const costOptimizedConfig = {
  tools: [
    {
      type: "web_search_20260209" as const,
      name: "web_search",
      dynamic_filtering: { enabled: true },
      // Limit searches per request
      max_uses: 3,
    },
  ],
  // Combine with Prompt Caching
  system: [
    {
      type: "text" as const,
      text: "You are a search-augmented AI assistant...",
      cache_control: { type: "ephemeral" as const },
    },
  ],
};
 
// Cost tracking utility
class CostTracker {
  private totalInputTokens = 0;
  private totalOutputTokens = 0;
  private totalSearches = 0;
  private totalCacheHits = 0;
 
  record(usage: {
    input_tokens: number;
    output_tokens: number;
    cache_read_input_tokens?: number;
  }, searches: number) {
    this.totalInputTokens += usage.input_tokens;
    this.totalOutputTokens += usage.output_tokens;
    this.totalSearches += searches;
    if (usage.cache_read_input_tokens) {
      this.totalCacheHits += usage.cache_read_input_tokens;
    }
  }
 
  getSummary() {
    // Sonnet 4.6 pricing: $3/M input, $15/M output
    const inputCost = (this.totalInputTokens / 1_000_000) * 3;
    const outputCost = (this.totalOutputTokens / 1_000_000) * 15;
    const cacheSavings =
      (this.totalCacheHits / 1_000_000) * 3 * 0.9;
 
    return {
      totalInputTokens: this.totalInputTokens,
      totalOutputTokens: this.totalOutputTokens,
      totalSearches: this.totalSearches,
      estimatedCost: `$${(inputCost + outputCost).toFixed(4)}`,
      cacheSavings: `$${cacheSavings.toFixed(4)}`,
      netCost: `$${(inputCost + outputCost - cacheSavings).toFixed(4)}`,
    };
  }
}

Prompt Caching × Web Search

Prompt Caching works with Web Search Tool requests. When reusing the same system prompt, caching reduces input tokens by up to 90%.

For a real-world prompt-caching cost example, see How I Cut My Claude API Bill in Half With Prompt Caching.

// Prompt Caching + Web Search integration
async function cachedSearchQuery(
  client: Anthropic,
  query: string
) {
  return await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 4096,
    // Cache the system prompt
    system: [
      {
        type: "text",
        text: `You are a technical research AI assistant.
Follow these rules:
1. Only answer based on search results
2. Always cite sources
3. Flag uncertain information
4. Warn about outdated information
5. Only include verified code examples`,
        cache_control: { type: "ephemeral" },
      },
    ],
    tools: [
      {
        type: "web_search_20260209",
        name: "web_search",
        dynamic_filtering: { enabled: true },
        max_uses: 3,
      },
    ],
    citations: { enabled: true },
    messages: [{ role: "user", content: query }],
  });
}
 
// Cost savings for sequential queries:
// 1st request: ~2000 input tokens (cache write at 1.25x)
// Subsequent: cache hit (0.1x = 90% savings)
// Dynamic Filtering code execution: free

Error Handling and Fallback Strategies

Production environments must handle search failures, rate limits, timeouts, and other errors gracefully.

Multi-Layer Fallback Implementation

import Anthropic from "@anthropic-ai/sdk";
 
class ResilientSearchAssistant {
  private client: Anthropic;
 
  constructor() {
    this.client = new Anthropic();
  }
 
  async answer(query: string): Promise<string> {
    // Layer 1: Web Search + Dynamic Filtering + Citations
    try {
      return await this.searchWithFullFeatures(query);
    } catch (error) {
      console.warn("Full search failed, falling back...", error);
    }
 
    // Layer 2: Basic Web Search (no Dynamic Filtering)
    try {
      return await this.searchBasic(query);
    } catch (error) {
      console.warn("Basic search failed, falling back...", error);
    }
 
    // Layer 3: Model knowledge only
    try {
      return await this.answerFromKnowledge(query);
    } catch (error) {
      console.error("All layers failed", error);
      throw new Error("Service temporarily unavailable");
    }
  }
 
  private async searchWithFullFeatures(
    query: string
  ): Promise<string> {
    const response = await this.client.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: 8096,
      tools: [
        {
          type: "web_search_20260209",
          name: "web_search",
          dynamic_filtering: { enabled: true },
          max_uses: 5,
        },
      ],
      citations: { enabled: true },
      messages: [{ role: "user", content: query }],
    });
 
    return this.extractText(response);
  }
 
  private async searchBasic(query: string): Promise<string> {
    const response = await this.client.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: 4096,
      tools: [
        {
          type: "web_search_20260209",
          name: "web_search",
          max_uses: 2,
        },
      ],
      messages: [{ role: "user", content: query }],
    });
 
    return this.extractText(response);
  }
 
  private async answerFromKnowledge(
    query: string
  ): Promise<string> {
    const response = await this.client.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: 4096,
      system:
        "Web search is unavailable. Answer based on your knowledge. " +
        "If information may not be current, clearly state this.",
      messages: [{ role: "user", content: query }],
    });
 
    return this.extractText(response);
  }
 
  private extractText(response: Anthropic.Message): string {
    return response.content
      .filter((b) => b.type === "text")
      .map((b) => (b as Anthropic.TextBlock).text)
      .join("");
  }
}

Rate Limit Handling

// Rate-limited request queue
class RateLimitedQueue {
  private queue: Array<() => Promise<void>> = [];
  private processing = false;
  private requestsPerMinute = 50;
  private interval = (60 / this.requestsPerMinute) * 1000;
 
  async enqueue<T>(fn: () => Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
      this.queue.push(async () => {
        try {
          const result = await fn();
          resolve(result);
        } catch (error) {
          // Respect retry-after on 429 errors
          if (
            error instanceof Anthropic.APIError &&
            error.status === 429
          ) {
            const retryAfter = 60;
            console.log(
              `Rate limited. Retrying after ${retryAfter}s...`
            );
            await new Promise((r) =>
              setTimeout(r, retryAfter * 1000)
            );
            try {
              const retryResult = await fn();
              resolve(retryResult);
            } catch (retryError) {
              reject(retryError);
            }
          } else {
            reject(error);
          }
        }
      });
      this.processQueue();
    });
  }
 
  private async processQueue() {
    if (this.processing) return;
    this.processing = true;
 
    while (this.queue.length > 0) {
      const task = this.queue.shift();
      if (task) {
        await task();
        await new Promise((r) => setTimeout(r, this.interval));
      }
    }
 
    this.processing = false;
  }
}

Practical Use Cases — Industry-Specific Examples

Use Case 1: Technical Documentation Search Bot

Build an internal bot for development teams that returns accurate answers sourced exclusively from official documentation.

const techDocBot = new SearchAugmentedAssistant({
  model: "claude-sonnet-4-6",
  systemPrompt: `You are a technical support bot for the development team.
Always cite official documentation as your source.
If the information is not found in official docs, say "Not found in official documentation."`,
  domainStrategy: "techDocs",
  reliabilityThreshold: 0.7,
});
 
// Usage
const answer = await techDocBot.answer(
  "How do I configure Extended Thinking in the Claude API?"
);
// → Accurate answer based on official docs + source URLs

Use Case 2: Real-Time News Analysis

Collect and analyze the latest news into structured reports.

const newsAnalyst = new SearchAugmentedAssistant({
  model: "claude-sonnet-4-6",
  systemPrompt: `You are an AI industry news analyst.
Search for the latest news and create analysis reports in this format:
1. Summary (3 lines max)
2. Key takeaways
3. Impact analysis
4. Source list`,
  domainStrategy: "news",
  reliabilityThreshold: 0.5,
});
 
const report = await newsAnalyst.answer(
  "Analyze this week's latest Anthropic and Claude-related news"
);

What the Official Docs Don't Tell You — Notes From Actually Running This

Maintaining my own apps as an indie developer, I kept running into small questions — "is this still the current way to call the SDK?", "did last week's update change this behavior?" — and I'd bounce between the official docs and the release notes every time. The same friction showed up when I needed to check whether an AdMob SDK update had shifted anything on the app side. So I wired up the search-augmented assistant from this article as a tiny personal fact-checking bot and pointed it at exactly those questions. A few things surfaced that the docs never mention.

Dynamic Filtering's effectiveness depends heavily on how specific the question is. For a concrete question like "list the parameters of the Claude API web_search tool," the results surviving the filter dropped to well under half and input tokens fell noticeably. For a vague question like "recent trends in AI," the filter barely narrowed anything and the token savings were marginal. Filtering pays off most when the question gives it a clear basis for narrowing.

A single reliability threshold across every use case eventually breaks. For technical-doc lookups I set reliabilityThreshold high at 0.7 and only returned an answer when the citations leaned on official domains — false certainty dropped clearly. For news summaries, 0.7 triggered too many re-searches and stretched latency, so I lowered it to 0.5. Trying to cover every use case with one number always strains somewhere.

Multi-layer fallback earns its keep by degrading quietly. When search fails, instead of returning an error, answer from the model's own knowledge but add "this may not be current." That one line kept the bot trustworthy. What matters isn't never failing — it's how the system behaves when it's about to.

Summary

By combining Claude API's Web Search Tool, Dynamic Filtering, and Citations API, you can build a search-augmented AI assistant that returns accurate, source-backed answers — a critical capability for production AI applications. With GA availability bringing improved stability and free code execution for Dynamic Filtering, the barriers to production deployment have dropped significantly.

The key takeaways are: use Dynamic Filtering to reduce token consumption by 40–60% while improving search accuracy; leverage Citations API to structurally ensure answer trustworthiness; combine with Prompt Caching for additional cost savings; and implement multi-layer fallback strategies for production reliability.

Start from the minimal setup with dynamic_filtering and citations enabled, and measure what reliability scores your own common questions produce. Tune the threshold and domain strategy from those measured values — that turns out to be the shortest path. I hope this helps with your implementation, and thank you for reading.

For estimating token cost up front, see Claude API Token Counting Guide.

Thank You for Reading

Claude Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

✦Copy-paste ready implementation code
✦New advanced guides published daily
✦$5/mo or $10 for lifetime access

View Membership →