# Anthropic Provider The [Anthropic](https://www.anthropic.com/) provider contains language model support for the [Anthropic Messages API](https://docs.anthropic.com/claude/reference/messages_post). ## Setup The Anthropic provider is available in the `@ai-sdk/anthropic` module. You can install it with ## Provider Instance You can import the default provider instance `anthropic` from `@ai-sdk/anthropic`: ```ts import { anthropic } from '@ai-sdk/anthropic'; ``` If you need a customized setup, you can import `createAnthropic` from `@ai-sdk/anthropic` and create a provider instance with your settings: ```ts import { createAnthropic } from '@ai-sdk/anthropic'; const anthropic = createAnthropic({ // custom settings }); ``` You can use the following optional settings to customize the Anthropic provider instance: - **baseURL** _string_ Use a different URL prefix for API calls, e.g. to use proxy servers. The default prefix is `https://api.anthropic.com/v1`. - **apiKey** _string_ API key that is being sent using the `x-api-key` header. It defaults to the `ANTHROPIC_API_KEY` environment variable. - **headers** _Record<string,string>_ Custom headers to include in the requests. - **fetch** _(input: RequestInfo, init?: RequestInit) => Promise<Response>_ Custom [fetch](https://developer.mozilla.org/en-US/docs/Web/API/fetch) implementation. Defaults to the global `fetch` function. You can use it as a middleware to intercept requests, or to provide a custom fetch implementation for e.g. testing. ## Language Models You can create models that call the [Anthropic Messages API](https://docs.anthropic.com/claude/reference/messages_post) using the provider instance. The first argument is the model id, e.g. `claude-3-haiku-20240307`. Some models have multi-modal capabilities. ```ts const model = anthropic('claude-3-haiku-20240307'); ``` You can use Anthropic language models to generate text with the `generateText` function: ```ts import { anthropic } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text } = await generateText({ model: anthropic('claude-3-haiku-20240307'), prompt: 'Write a vegetarian lasagna recipe for 4 people.', }); ``` Anthropic language models can also be used in the `streamText`, `generateObject`, and `streamObject` functions (see [AI SDK Core](/docs/ai-sdk-core)). The following optional provider options are available for Anthropic models: - `disableParallelToolUse` _boolean_ Optional. Disables the use of parallel tool calls. Defaults to `false`. When set to `true`, the model will only call one tool at a time instead of potentially calling multiple tools in parallel. - `sendReasoning` _boolean_ Optional. Include reasoning content in requests sent to the model. Defaults to `true`. If you are experiencing issues with the model handling requests involving reasoning content, you can set this to `false` to omit them from the request. - `effort` _"low" | "medium" | "high" | "xhigh" | "max"_ Optional. See [Effort section](#effort) for more details. - `taskBudget` _object_ Optional. See [Task Budgets section](#task-budgets) for more details. - `speed` _"fast" | "standard"_ Optional. See [Fast Mode section](#fast-mode) for more details. - `inferenceGeo` _"us" | "global"_ Optional. See [Data Residency section](#data-residency) for more details. - `thinking` _object_ Optional. See [Reasoning section](#reasoning) for more details. - `effort` _"high" | "medium" | "low"_ Optional. See [Effort section](#effort) for more details. - `toolStreaming` _boolean_ Whether to enable tool streaming (and structured output streaming). Default to `true`. - `structuredOutputMode` _"outputFormat" | "jsonTool" | "auto"_ Determines how structured outputs are generated. Optional. - `"outputFormat"`: Use the `output_format` parameter to specify the structured output format. - `"jsonTool"`: Use a special `"json"` tool to specify the structured output format (default). - `"auto"`: Use `"outputFormat"` when supported, otherwise fall back to `"jsonTool"`. - `metadata` _object_ Optional. Metadata to include with the request. See the [Anthropic API documentation](https://platform.claude.com/docs/en/api/messages/create) for details. - `userId` _string_ - An external identifier for the end-user. Should be a UUID, hash, or other opaque identifier. Must not contain PII. ### Structured Outputs and Tool Input Streaming By default, the Anthropic API returns streaming tool calls and structured outputs all at once after a delay. To enable incremental streaming of tool inputs (when using `streamText` with tools) and structured outputs (when using `streamObject`), you need to set the `anthropic-beta` header to `fine-grained-tool-streaming-2025-05-14`. #### For structured outputs with `streamObject` ```ts import { anthropic } from '@ai-sdk/anthropic'; import { streamObject } from 'ai'; import { z } from 'zod'; const result = streamObject({ model: anthropic('claude-sonnet-4-20250514'), schema: z.object({ characters: z.array( z.object({ name: z.string(), class: z.string(), description: z.string(), }), ), }), prompt: 'Generate 3 character descriptions for a fantasy role playing game.', headers: { 'anthropic-beta': 'fine-grained-tool-streaming-2025-05-14', }, }); for await (const partialObject of result.partialObjectStream) { console.log(partialObject); } ``` #### For tool input streaming with `streamText` ```ts import { anthropic } from '@ai-sdk/anthropic'; import { streamText, tool } from 'ai'; import { z } from 'zod'; const result = streamText({ model: anthropic('claude-sonnet-4-20250514'), tools: { writeFile: tool({ description: 'Write content to a file', inputSchema: z.object({ path: z.string(), content: z.string(), }), execute: async ({ path, content }) => { // Implementation return { success: true }; }, }), }, prompt: 'Write a short story to story.txt', headers: { 'anthropic-beta': 'fine-grained-tool-streaming-2025-05-14', }, }); ``` Without this header, tool inputs and structured outputs may arrive all at once after a delay instead of streaming incrementally. ### Effort Anthropic introduced an `effort` option with `claude-opus-4-5` that affects thinking, text responses, and function calls. Effort defaults to `high` and you can set it to `medium` or `low` to save tokens and to lower time-to-last-token latency (TTLT). `claude-opus-4-7` additionally supports `xhigh` for maximum reasoning effort. ```ts highlight="8-10" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text, usage } = await generateText({ model: anthropic('claude-opus-4-20250514'), prompt: 'How many people will live in the world in 2040?', providerOptions: { anthropic: { effort: 'low', } satisfies AnthropicProviderOptions, }, }); console.log(text); // resulting text console.log(usage); // token usage ``` ### Fast Mode Anthropic supports a [`speed` option](https://code.claude.com/docs/en/fast-mode) for `claude-opus-4-6` that enables faster inference with approximately 2.5x faster output token speeds. ```ts highlight="8-10" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text } = await generateText({ model: anthropic('claude-opus-4-6'), prompt: 'Write a short poem about the sea.', providerOptions: { anthropic: { speed: 'fast', } satisfies AnthropicProviderOptions, }, }); ``` The `speed` option accepts `'fast'` or `'standard'` (default behavior). ### Data Residency Anthropic supports an [`inferenceGeo` option](https://platform.claude.com/docs/en/build-with-claude/data-residency) that controls where model inference runs for a request. ```ts highlight="8-10" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text } = await generateText({ model: anthropic('claude-opus-4-6'), prompt: 'Summarize the key points of this document.', providerOptions: { anthropic: { inferenceGeo: 'us', } satisfies AnthropicProviderOptions, }, }); ``` The `inferenceGeo` option accepts `'us'` (US-only infrastructure) or `'global'` (default, any available geography). ### Task Budgets `claude-opus-4-7` supports a `taskBudget` option that informs the model of the total token budget available for an agentic turn. The model uses this information to prioritize work, plan ahead, and wind down gracefully as the budget is consumed. Task budgets are advisory — they do not enforce a hard token limit. The model will attempt to stay within budget, but actual usage may vary. ```ts highlight="8-13" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text } = await generateText({ model: anthropic('claude-opus-4-7'), prompt: 'Research the pros and cons of Rust vs Go for building CLI tools.', providerOptions: { anthropic: { taskBudget: { type: 'tokens', total: 400000, }, } satisfies AnthropicProviderOptions, }, }); ``` For long-running agents that compact and restart context, you can carry the remaining budget forward using the `remaining` field: ```ts taskBudget: { type: 'tokens', total: 400000, remaining: 215000, // budget left after prior compacted-away contexts } ``` The `taskBudget` object accepts: - `type` _"tokens"_ - Budget type. Currently only `"tokens"` is supported. - `total` _number_ - Total task budget for the agentic turn. Minimum 20,000. - `remaining` _number_ - Budget left after prior compacted-away contexts. Must be between 0 and `total`. Defaults to `total` if omitted. ### Reasoning Anthropic has reasoning support for `claude-opus-4-20250514`, `claude-sonnet-4-20250514`, and `claude-3-7-sonnet-20250219` models. You can enable it using the `thinking` provider option and specifying a thinking budget in tokens. ```ts highlight="4,8-10" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text, reasoningText, reasoning } = await generateText({ model: anthropic('claude-opus-4-6'), prompt: 'How many people will live in the world in 2040?', providerOptions: { anthropic: { thinking: { type: 'adaptive' }, } satisfies AnthropicProviderOptions, }, }); console.log(reasoningText); // reasoning text console.log(reasoning); // reasoning details including redacted reasoning console.log(text); // text response ``` You can combine adaptive thinking with the `effort` option to control how much reasoning Claude uses: ```ts highlight="6-8" const { text } = await generateText({ model: anthropic('claude-opus-4-6'), prompt: 'Invent a new holiday and describe its traditions.', providerOptions: { anthropic: { thinking: { type: 'adaptive' }, effort: 'max', // 'low' | 'medium' | 'high' | 'xhigh' | 'max' } satisfies AnthropicProviderOptions, }, }); ``` ##### Thinking Display (Opus 4.7+) Starting with `claude-opus-4-7`, thinking content is omitted from the response by default — thinking blocks are present in the stream but their text is empty. To receive reasoning output, set `display: 'summarized'`: ```ts highlight="5" const { text, reasoningText } = await generateText({ model: anthropic('claude-opus-4-7'), providerOptions: { anthropic: { thinking: { type: 'adaptive', display: 'summarized' }, } satisfies AnthropicProviderOptions, }, prompt: 'How many people will live in the world in 2040?', }); console.log(reasoningText); // reasoning text (empty without display: 'summarized') console.log(text); ``` If you stream reasoning to users with `claude-opus-4-7`, the default `"omitted"` display will cause a long pause before output begins. Set `display: "summarized"` to restore visible progress during thinking. #### Budget-Based Thinking For earlier models (`claude-opus-4-20250514`, `claude-sonnet-4-20250514`, `claude-sonnet-4-5-20250929`), use `type: 'enabled'` with an explicit token budget: ```ts highlight="4,8-10" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const { text, reasoningText, reasoning } = await generateText({ model: anthropic('claude-sonnet-4-5-20250929'), prompt: 'How many people will live in the world in 2040?', providerOptions: { anthropic: { thinking: { type: 'enabled', budgetTokens: 12000 }, } satisfies AnthropicProviderOptions, }, }); console.log(reasoningText); // reasoning text console.log(reasoning); // reasoning details including redacted reasoning console.log(text); // text response ``` See [AI SDK UI: Chatbot](/docs/ai-sdk-ui/chatbot#reasoning) for more details on how to integrate reasoning into your chatbot. ### Cache Control In the messages and message parts, you can use the `providerOptions` property to set cache control breakpoints. You need to set the `anthropic` property in the `providerOptions` object to `{ cacheControl: { type: 'ephemeral' } }` to set a cache control breakpoint. The cache creation input tokens are then returned in the `providerMetadata` object for `generateText` and `generateObject`, again under the `anthropic` property. When you use `streamText` or `streamObject`, the response contains a promise that resolves to the metadata. Alternatively you can receive it in the `onFinish` callback. ```ts highlight="8,18-20,29-30" import { anthropic } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const errorMessage = '... long error message ...'; const result = await generateText({ model: anthropic('claude-3-5-sonnet-20240620'), messages: [ { role: 'user', content: [ { type: 'text', text: 'You are a JavaScript expert.' }, { type: 'text', text: `Error message: ${errorMessage}`, providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } }, }, }, { type: 'text', text: 'Explain the error message.' }, ], }, ], }); console.log(result.text); console.log(result.providerMetadata?.anthropic); // e.g. { cacheCreationInputTokens: 2118 } ``` You can also use cache control on system messages by providing multiple system messages at the head of your messages array: ```ts highlight="3,7-9" const result = await generateText({ model: anthropic('claude-3-5-sonnet-20240620'), messages: [ { role: 'system', content: 'Cached system message part', providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } }, }, }, { role: 'system', content: 'Uncached system message part', }, { role: 'user', content: 'User prompt', }, ], }); ``` Cache control for tools: ```ts const result = await generateText({ model: anthropic('claude-3-5-haiku-latest'), tools: { cityAttractions: tool({ inputSchema: z.object({ city: z.string() }), providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' }, }, }, }), }, messages: [ { role: 'user', content: 'User prompt', }, ], }); ``` #### Longer cache TTL Anthropic also supports a longer 1-hour cache duration. Here's an example: ```ts const result = await generateText({ model: anthropic('claude-3-5-haiku-latest'), messages: [ { role: 'user', content: [ { type: 'text', text: 'Long cached message', providerOptions: { anthropic: { cacheControl: { type: 'ephemeral', ttl: '1h' }, }, }, }, ], }, ], }); ``` #### Limitations The minimum cacheable prompt length is: - 1024 tokens for Claude 3.7 Sonnet, Claude 3.5 Sonnet and Claude 3 Opus - 2048 tokens for Claude 3.5 Haiku and Claude 3 Haiku Shorter prompts cannot be cached, even if marked with `cacheControl`. Any requests to cache fewer than this number of tokens will be processed without caching. For more on prompt caching with Anthropic, see [Anthropic's Cache Control documentation](https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching). Because the `UIMessage` type (used by AI SDK UI hooks like `useChat`) does not support the `providerOptions` property, you can use `convertToModelMessages` first before passing the messages to functions like `generateText` or `streamText`. For more details on `providerOptions` usage, see [here](/docs/foundations/prompts#provider-options). ### Bash Tool The Bash Tool allows running bash commands. Here's how to create and use it: ```ts const bashTool = anthropic.tools.bash_20241022({ execute: async ({ command, restart }) => { // Implement your bash command execution logic here // Return the result of the command execution }, }); ``` Parameters: - `command` (string): The bash command to run. Required unless the tool is being restarted. - `restart` (boolean, optional): Specifying true will restart this tool. The bash tool must have the name `bash`. Only certain Claude versions are supported. ### Memory Tool The [Memory Tool](https://docs.claude.com/en/docs/agents-and-tools/tool-use/memory-tool) allows Claude to use a local memory, e.g. in the filesystem. Here's how to create it: ```ts const memory = anthropic.tools.memory_20250818({ execute: async action => { // Implement your memory command execution logic here // Return the result of the command execution }, }); ``` The memory tool must have the name `memory`. Only certain Claude versions are supported. ### Text Editor Tool The Text Editor Tool provides functionality for viewing and editing text files. ```ts const tools = { // tool name must be str_replace_based_edit_tool str_replace_based_edit_tool: anthropic.tools.textEditor_20250728({ maxCharacters: 10000, // optional async execute({ command, path, old_str, new_str }) { // ... }, }), } satisfies ToolSet; ``` Different models support different versions of the tool. For Claude Sonnet 3.5 and 3.7 you need to use older tool versions and tool names. Parameters: - `command` ('view' | 'create' | 'str_replace' | 'insert' | 'undo_edit'): The command to run. Note: `undo_edit` is only available in Claude 3.5 Sonnet and earlier models. - `path` (string): Absolute path to file or directory, e.g. `/repo/file.py` or `/repo`. - `file_text` (string, optional): Required for `create` command, with the content of the file to be created. - `insert_line` (number, optional): Required for `insert` command. The line number after which to insert the new string. - `new_str` (string, optional): New string for `str_replace` or `insert` commands. - `old_str` (string, optional): Required for `str_replace` command, containing the string to replace. - `view_range` (number[], optional): Optional for `view` command to specify line range to show. ### Computer Tool The Computer Tool enables control of keyboard and mouse actions on a computer: ```ts const computerTool = anthropic.tools.computer_20241022({ displayWidthPx: 1920, displayHeightPx: 1080, displayNumber: 0, // Optional, for X11 environments execute: async ({ action, coordinate, text }) => { // Implement your computer control logic here // Return the result of the action // Example code: switch (action) { case 'screenshot': { // multipart result: return { type: 'image', data: fs .readFileSync('./data/screenshot-editor.png') .toString('base64'), }; } default: { console.log('Action:', action); console.log('Coordinate:', coordinate); console.log('Text:', text); return `executed ${action}`; } } }, // map to tool result content for LLM consumption: toModelOutput(result) { return typeof result === 'string' ? [{ type: 'text', text: result }] : [{ type: 'image', data: result.data, mediaType: 'image/png' }]; }, }); ``` Parameters: - `action` ('key' | 'type' | 'mouse_move' | 'left_click' | 'left_click_drag' | 'right_click' | 'middle_click' | 'double_click' | 'screenshot' | 'cursor_position'): The action to perform. - `coordinate` (number[], optional): Required for `mouse_move` and `left_click_drag` actions. Specifies the (x, y) coordinates. - `text` (string, optional): Required for `type` and `key` actions. These tools can be used in conjunction with the `sonnet-3-5-sonnet-20240620` model to enable more complex interactions and tasks. ### Web Search Tool Anthropic provides a provider-defined web search tool that gives Claude direct access to real-time web content, allowing it to answer questions with up-to-date information beyond its knowledge cutoff. You can enable web search using the provider-defined web search tool: ```ts import { anthropic } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const webSearchTool = anthropic.tools.webSearch_20250305({ maxUses: 5, }); const result = await generateText({ model: anthropic('claude-opus-4-20250514'), prompt: 'What are the latest developments in AI?', tools: { web_search: webSearchTool, }, }); ``` Web search must be enabled in your organization's [Console settings](https://console.anthropic.com/settings/privacy). #### Configuration Options The web search tool supports several configuration options: - **maxUses** _number_ Maximum number of web searches Claude can perform during the conversation. - **allowedDomains** _string[]_ Optional list of domains that Claude is allowed to search. If provided, searches will be restricted to these domains. - **blockedDomains** _string[]_ Optional list of domains that Claude should avoid when searching. - **userLocation** _object_ Optional user location information to provide geographically relevant search results. ```ts const webSearchTool = anthropic.tools.webSearch_20250305({ maxUses: 3, allowedDomains: ['techcrunch.com', 'wired.com'], blockedDomains: ['example-spam-site.com'], userLocation: { type: 'approximate', country: 'US', region: 'California', city: 'San Francisco', timezone: 'America/Los_Angeles', }, }); const result = await generateText({ model: anthropic('claude-opus-4-20250514'), prompt: 'Find local news about technology', tools: { web_search: webSearchTool, }, }); ``` ### Web Fetch Tool Anthropic provides a provider-defined web fetch tool that allows Claude to retrieve content from specific URLs. This is useful when you want Claude to analyze or reference content from a particular webpage or document. You can enable web fetch using the provider-defined web fetch tool: ```ts import { anthropic } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const result = await generateText({ model: anthropic('claude-sonnet-4-0'), prompt: 'What is this page about? https://en.wikipedia.org/wiki/Maglemosian_culture', tools: { web_fetch: anthropic.tools.webFetch_20250910({ maxUses: 1 }), }, }); ``` #### Configuration Options The web fetch tool supports several configuration options: - **maxUses** _number_ The maxUses parameter limits the number of web fetches performed. - **allowedDomains** _string[]_ Only fetch from these domains. - **blockedDomains** _string[]_ Never fetch from these domains. - **citations** _object_ Unlike web search where citations are always enabled, citations are optional for web fetch. Set `"citations": {"enabled": true}` to enable Claude to cite specific passages from fetched documents. - **maxContentTokens** _number_ The maxContentTokens parameter limits the amount of content that will be included in the context. #### Error Handling Web search errors are handled differently depending on whether you're using streaming or non-streaming: **Non-streaming (`generateText`, `generateObject`):** Web search errors throw exceptions that you can catch: ```ts try { const result = await generateText({ model: anthropic('claude-opus-4-20250514'), prompt: 'Search for something', tools: { web_search: webSearchTool, }, }); } catch (error) { if (error.message.includes('Web search failed')) { console.log('Search error:', error.message); // Handle search error appropriately } } ``` **Streaming (`streamText`, `streamObject`):** Web search errors are delivered as error parts in the stream: ```ts const result = await streamText({ model: anthropic('claude-opus-4-20250514'), prompt: 'Search for something', tools: { web_search: webSearchTool, }, }); for await (const part of result.textStream) { if (part.type === 'error') { console.log('Search error:', part.error); // Handle search error appropriately } } ``` ## Code Execution Anthropic provides a provider-defined code execution tool that gives Claude direct access to a real Python environment allowing it to execute code to inform its responses. You can enable code execution using the provider-defined code execution tool: ```ts import { anthropic } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const codeExecutionTool = anthropic.tools.codeExecution_20260120(); const result = await generateText({ model: anthropic('claude-opus-4-20250514'), prompt: 'Calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]', tools: { code_execution: codeExecutionTool, }, }); ``` Three versions are available: `codeExecution_20260120` (recommended, does not require a beta header, supports Claude Opus 4.6, Sonnet 4.6, Sonnet 4.5, and Opus 4.5), `codeExecution_20250825` (supports Python and Bash with enhanced file operations), and `codeExecution_20250522` (supports Bash only). #### Error Handling Code execution errors are handled differently depending on whether you're using streaming or non-streaming: **Non-streaming (`generateText`, `generateObject`):** Code execution errors are delivered as tool result parts in the response: ```ts const result = await generateText({ model: anthropic('claude-opus-4-20250514'), prompt: 'Execute some Python script', tools: { code_execution: codeExecutionTool, }, }); const toolErrors = result.content?.filter( content => content.type === 'tool-error', ); toolErrors?.forEach(error => { console.error('Tool execution error:', { toolName: error.toolName, toolCallId: error.toolCallId, error: error.error, }); }); ``` **Streaming (`streamText`, `streamObject`):** Code execution errors are delivered as error parts in the stream: ```ts const result = await streamText({ model: anthropic('claude-opus-4-20250514'), prompt: 'Execute some Python script', tools: { code_execution: codeExecutionTool, }, }); for await (const part of result.textStream) { if (part.type === 'error') { console.log('Code execution error:', part.error); // Handle code execution error appropriately } } ``` ## Agent Skills [Anthropic Agent Skills](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview) enable Claude to perform specialized tasks like document processing (PPTX, DOCX, PDF, XLSX) and data analysis. Skills run in a sandboxed container and require the code execution tool to be enabled. ### Using Built-in Skills Anthropic provides several built-in skills: - **pptx** - Create and edit PowerPoint presentations - **docx** - Create and edit Word documents - **pdf** - Process and analyze PDF files - **xlsx** - Work with Excel spreadsheets To use skills, you need to: 1. Enable the code execution tool 2. Specify the container with skills in `providerOptions` ```ts highlight="4,9-17,19-23" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { generateText } from 'ai'; const result = await generateText({ model: anthropic('claude-sonnet-4-5'), tools: { code_execution: anthropic.tools.codeExecution_20260120(), }, prompt: 'Create a presentation about renewable energy with 5 slides', providerOptions: { anthropic: { container: { skills: [ { type: 'anthropic', skillId: 'pptx', version: 'latest', // optional }, ], }, } satisfies AnthropicProviderOptions, }, }); ``` ### Custom Skills You can also use custom skills by specifying `type: 'custom'`: ```ts highlight="9-11" const result = await generateText({ model: anthropic('claude-sonnet-4-5'), tools: { code_execution: anthropic.tools.codeExecution_20260120(), }, prompt: 'Use my custom skill to process this data', providerOptions: { anthropic: { container: { skills: [ { type: 'custom', skillId: 'my-custom-skill-id', version: '1.0', // optional }, ], }, } satisfies AnthropicProviderOptions, }, }); ``` Skills use progressive context loading and execute within a sandboxed container with code execution capabilities. ### Compaction The `compact_20260112` edit type automatically summarizes earlier conversation context when token limits are reached. This is useful for long-running conversations where you want to preserve the essence of earlier exchanges while staying within token limits. ```ts highlight="7-19" import { anthropic, AnthropicProviderOptions } from '@ai-sdk/anthropic'; import { streamText } from 'ai'; const result = streamText({ model: anthropic('claude-opus-4-6'), messages: conversationHistory, providerOptions: { anthropic: { contextManagement: { edits: [ { type: 'compact_20260112', trigger: { type: 'input_tokens', value: 50000, // trigger compaction when input exceeds 50k tokens }, instructions: 'Summarize the conversation concisely, preserving key decisions and context.', pauseAfterCompaction: false, }, ], }, } satisfies AnthropicProviderOptions, }, }); ``` **Configuration:** - **trigger** - Condition that triggers compaction (e.g., `{ type: 'input_tokens', value: 50000 }`) - **instructions** - Custom instructions for how the model should summarize the conversation. Use this to guide the compaction summary towards specific aspects of the conversation you want to preserve. - **pauseAfterCompaction** - When `true`, the model will pause after generating the compaction summary, allowing you to inspect or process it before continuing. Defaults to `false`. When compaction occurs, the model generates a summary of the earlier context. This summary appears as a text block with special provider metadata. #### Detecting Compaction in Streams When using `streamText`, you can detect compaction summaries by checking the `providerMetadata` on `text-start` events: ```ts for await (const part of result.fullStream) { switch (part.type) { case 'text-start': { const isCompaction = part.providerMetadata?.anthropic?.type === 'compaction'; if (isCompaction) { console.log('[COMPACTION SUMMARY START]'); } break; } case 'text-delta': { process.stdout.write(part.text); break; } } } ``` #### Compaction in UI Applications When using `useChat` or other UI hooks, compaction summaries appear as regular text parts with `providerMetadata`. You can style them differently in your UI: ```tsx { message.parts.map((part, index) => { if (part.type === 'text') { const isCompaction = (part.providerMetadata?.anthropic as { type?: string } | undefined) ?.type === 'compaction'; if (isCompaction) { return (
[Compaction Summary]
{part.text}
); } return
{part.text}
; } }); } ``` ### PDF support Anthropic Sonnet `claude-3-5-sonnet-20241022` supports reading PDF files. You can pass PDF files as part of the message content using the `file` type: Option 1: URL-based PDF document ```ts const result = await generateText({ model: anthropic('claude-3-5-sonnet-20241022'), messages: [ { role: 'user', content: [ { type: 'text', text: 'What is an embedding model according to this document?', }, { type: 'file', data: new URL( 'https://github.com/vercel/ai/blob/main/examples/ai-core/data/ai.pdf?raw=true', ), mimeType: 'application/pdf', }, ], }, ], }); ``` Option 2: Base64-encoded PDF document ```ts const result = await generateText({ model: anthropic('claude-3-5-sonnet-20241022'), messages: [ { role: 'user', content: [ { type: 'text', text: 'What is an embedding model according to this document?', }, { type: 'file', data: fs.readFileSync('./data/ai.pdf'), mediaType: 'application/pdf', }, ], }, ], }); ``` The model will have access to the contents of the PDF file and respond to questions about it. The PDF file should be passed using the `data` field, and the `mediaType` should be set to `'application/pdf'`. ### Model Capabilities | Model | Image Input | Object Generation | Tool Usage | Computer Use | Web Search | Tool Search | Compaction | | -------------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | | `claude-opus-4-7` | | | | | | | | | `claude-opus-4-6` | | | | | | | | | `claude-sonnet-4-6` | | | | | | | | | `claude-opus-4-5` | | | | | | | | | `claude-haiku-4-5` | | | | | | | | | `claude-sonnet-4-5` | | | | | | | | | `claude-opus-4-1` | | | | | | | | | `claude-opus-4-0` | | | | | | | | | `claude-sonnet-4-0` | | | | | | | | | `claude-3-7-sonnet-latest` | | | | | | | | | `claude-3-5-haiku-latest` | | | | | | | | The table above lists popular models. Please see the [Anthropic docs](https://docs.anthropic.com/en/docs/about-claude/models) for a full list of available models. The table above lists popular models. You can also pass any available provider model ID as a string if needed. ## Navigation - [AI Gateway](/v5/providers/ai-sdk-providers/ai-gateway) - [xAI Grok](/v5/providers/ai-sdk-providers/xai) - [Vercel](/v5/providers/ai-sdk-providers/vercel) - [OpenAI](/v5/providers/ai-sdk-providers/openai) - [Azure OpenAI](/v5/providers/ai-sdk-providers/azure) - [Anthropic](/v5/providers/ai-sdk-providers/anthropic) - [Amazon Bedrock](/v5/providers/ai-sdk-providers/amazon-bedrock) - [Groq](/v5/providers/ai-sdk-providers/groq) - [Fal](/v5/providers/ai-sdk-providers/fal) - [AssemblyAI](/v5/providers/ai-sdk-providers/assemblyai) - [DeepInfra](/v5/providers/ai-sdk-providers/deepinfra) - [Deepgram](/v5/providers/ai-sdk-providers/deepgram) - [Black Forest Labs](/v5/providers/ai-sdk-providers/black-forest-labs) - [Gladia](/v5/providers/ai-sdk-providers/gladia) - [LMNT](/v5/providers/ai-sdk-providers/lmnt) - [Google Generative AI](/v5/providers/ai-sdk-providers/google-generative-ai) - [Hume](/v5/providers/ai-sdk-providers/hume) - [Google Vertex AI](/v5/providers/ai-sdk-providers/google-vertex) - [Rev.ai](/v5/providers/ai-sdk-providers/revai) - [Baseten](/v5/providers/ai-sdk-providers/baseten) - [Hugging Face](/v5/providers/ai-sdk-providers/huggingface) - [Mistral AI](/v5/providers/ai-sdk-providers/mistral) - [Together.ai](/v5/providers/ai-sdk-providers/togetherai) - [Cohere](/v5/providers/ai-sdk-providers/cohere) - [Fireworks](/v5/providers/ai-sdk-providers/fireworks) - [DeepSeek](/v5/providers/ai-sdk-providers/deepseek) - [Moonshot AI](/v5/providers/ai-sdk-providers/moonshotai) - [Alibaba](/v5/providers/ai-sdk-providers/alibaba) - [Cerebras](/v5/providers/ai-sdk-providers/cerebras) - [Replicate](/v5/providers/ai-sdk-providers/replicate) - [Perplexity](/v5/providers/ai-sdk-providers/perplexity) - [Luma](/v5/providers/ai-sdk-providers/luma) - [ElevenLabs](/v5/providers/ai-sdk-providers/elevenlabs) [Full Sitemap](/sitemap.md)