# 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` _"high" | "medium" | "low"_
Optional. See [Effort section](#effort) for more details.
- `speed` _"fast" | "standard"_
Optional. See [Fast Mode section](#fast-mode) 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).
```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).
### 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, reasoning, reasoningDetails } = await generateText({
model: anthropic('claude-opus-4-20250514'),
prompt: 'How many people will live in the world in 2040?',
providerOptions: {
anthropic: {
thinking: { type: 'enabled', budgetTokens: 12000 },
} satisfies AnthropicProviderOptions,
},
});
console.log(reasoning); // reasoning text
console.log(reasoningDetails); // 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-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)