xAI Grok Provider

1
import { xai } from '@ai-sdk/xai';

1
import { createXai } from '@ai-sdk/xai';
2

3
const xai = createXai({
4
  apiKey: 'your-api-key',
5
});

1
const model = xai('grok-3');

1
import { xai } from '@ai-sdk/xai';
2
import { generateText } from 'ai';
3

4
const { text } = await generateText({
5
  model: xai('grok-3'),
6
  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
7
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const model = xai('grok-3-mini');
4

5
await generateText({
6
  model,
7
  providerOptions: {
8
    xai: {
9
      reasoningEffort: 'high',
10
    } satisfies XaiLanguageModelChatOptions,
11
  },
12
});

1
const model = xai.responses('grok-4-fast-non-reasoning');

1
import { xai } from '@ai-sdk/xai';
2
import { generateText } from 'ai';
3

4
const { text } = await generateText({
5
  model: xai.responses('grok-3'),
6
  messages: [
7
    {
8
      role: 'user',
9
      content: [
10
        { type: 'text', text: 'What do you see in this image?' },
11
        { type: 'image', image: fs.readFileSync('./image.png') },
12
      ],
13
    },
14
  ],
15
});

1
import { xai } from '@ai-sdk/xai';
2
import { generateText } from 'ai';
3

4
const { text, sources } = await generateText({
5
  model: xai.responses('grok-4-fast-non-reasoning'),
6
  prompt: 'What are the latest developments in AI?',
7
  tools: {
8
    web_search: xai.tools.webSearch({
9
      allowedDomains: ['arxiv.org', 'openai.com'],
10
      enableImageUnderstanding: true,
11
    }),
12
  },
13
});
14

15
console.log(text);
16
console.log('Citations:', sources);

1
const { text, sources } = await generateText({
2
  model: xai.responses('grok-4-fast-non-reasoning'),
3
  prompt: 'What are people saying about AI on X this week?',
4
  tools: {
5
    x_search: xai.tools.xSearch({
6
      allowedXHandles: ['elonmusk', 'xai'],
7
      fromDate: '2025-10-23',
8
      toDate: '2025-10-30',
9
      enableImageUnderstanding: true,
10
      enableVideoUnderstanding: true,
11
    }),
12
  },
13
});

1
const { text } = await generateText({
2
  model: xai.responses('grok-4-fast-non-reasoning'),
3
  prompt:
4
    'Calculate the compound interest for $10,000 at 5% annually for 10 years',
5
  tools: {
6
    code_execution: xai.tools.codeExecution(),
7
  },
8
});

1
const { text } = await generateText({
2
  model: xai.responses('grok-4-fast-non-reasoning'),
3
  prompt: 'Describe what you see in the image',
4
  tools: {
5
    view_image: xai.tools.viewImage(),
6
  },
7
});

1
const { text } = await generateText({
2
  model: xai.responses('grok-4-fast-non-reasoning'),
3
  prompt: 'Summarize the content of this X video',
4
  tools: {
5
    view_x_video: xai.tools.viewXVideo(),
6
  },
7
});

1
const { text } = await generateText({
2
  model: xai.responses('grok-4-fast-non-reasoning'),
3
  prompt: 'Use the weather tool to check conditions in San Francisco',
4
  tools: {
5
    weather_server: xai.tools.mcpServer({
6
      serverUrl: 'https://example.com/mcp',
7
      serverLabel: 'weather-service',
8
      serverDescription: 'Weather data provider',
9
      allowedTools: ['get_weather', 'get_forecast'],
10
    }),
11
  },
12
});

1
import { xai, type XaiLanguageModelResponsesOptions } from '@ai-sdk/xai';
2
import { streamText } from 'ai';
3

4
const result = streamText({
5
  model: xai.responses('grok-4-1-fast-reasoning'),
6
  prompt: 'What documents do you have access to?',
7
  tools: {
8
    file_search: xai.tools.fileSearch({
9
      vectorStoreIds: ['collection_your-collection-id'],
10
      maxNumResults: 10,
11
    }),
12
  },
13
  providerOptions: {
14
    xai: {
15
      include: ['file_search_call.results'],
16
    } satisfies XaiLanguageModelResponsesOptions,
17
  },
18
});

1
import { xai } from '@ai-sdk/xai';
2
import { streamText } from 'ai';
3

4
const { fullStream } = streamText({
5
  model: xai.responses('grok-4-fast-non-reasoning'),
6
  prompt: 'Research AI safety developments and calculate risk metrics',
7
  tools: {
8
    web_search: xai.tools.webSearch(),
9
    x_search: xai.tools.xSearch(),
10
    code_execution: xai.tools.codeExecution(),
11
    file_search: xai.tools.fileSearch({
12
      vectorStoreIds: ['collection_your-documents'],
13
    }),
14
    data_service: xai.tools.mcpServer({
15
      serverUrl: 'https://data.example.com/mcp',
16
      serverLabel: 'data-service',
17
    }),
18
  },
19
});
20

21
for await (const part of fullStream) {
22
  if (part.type === 'text-delta') {
23
    process.stdout.write(part.text);
24
  } else if (part.type === 'source' && part.sourceType === 'url') {
25
    console.log('\nSource:', part.url);
26
  }
27
}

1
import { xai, type XaiLanguageModelResponsesOptions } from '@ai-sdk/xai';
2
import { generateText } from 'ai';
3

4
const result = await generateText({
5
  model: xai.responses('grok-4-fast-non-reasoning'),
6
  providerOptions: {
7
    xai: {
8
      reasoningEffort: 'high',
9
    } satisfies XaiLanguageModelResponsesOptions,
10
  },
11
  // ...
12
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2
import { generateText } from 'ai';
3

4
const { text, sources } = await generateText({
5
  model: xai('grok-3-latest'),
6
  prompt: 'What are the latest developments in AI?',
7
  providerOptions: {
8
    xai: {
9
      searchParameters: {
10
        mode: 'auto', // 'auto', 'on', or 'off'
11
        returnCitations: true,
12
        maxSearchResults: 5,
13
      },
14
    } satisfies XaiLanguageModelChatOptions,
15
  },
16
});
17

18
console.log(text);
19
console.log('Sources:', sources);

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const result = await generateText({
4
  model: xai('grok-3-latest'),
5
  prompt: 'Best ski resorts in Switzerland',
6
  providerOptions: {
7
    xai: {
8
      searchParameters: {
9
        mode: 'on',
10
        sources: [
11
          {
12
            type: 'web',
13
            country: 'CH', // ISO alpha-2 country code
14
            allowedWebsites: ['ski.com', 'snow-forecast.com'],
15
            safeSearch: true,
16
          },
17
        ],
18
      },
19
    } satisfies XaiLanguageModelChatOptions,
20
  },
21
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const result = await generateText({
4
  model: xai('grok-3-latest'),
5
  prompt: 'Latest updates on Grok AI',
6
  providerOptions: {
7
    xai: {
8
      searchParameters: {
9
        mode: 'on',
10
        sources: [
11
          {
12
            type: 'x',
13
            includedXHandles: ['grok', 'xai'],
14
            excludedXHandles: ['openai'],
15
            postFavoriteCount: 10,
16
            postViewCount: 100,
17
          },
18
        ],
19
      },
20
    } satisfies XaiLanguageModelChatOptions,
21
  },
22
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const result = await generateText({
4
  model: xai('grok-3-latest'),
5
  prompt: 'Recent tech industry news',
6
  providerOptions: {
7
    xai: {
8
      searchParameters: {
9
        mode: 'on',
10
        sources: [
11
          {
12
            type: 'news',
13
            country: 'US',
14
            excludedWebsites: ['tabloid.com'],
15
            safeSearch: true,
16
          },
17
        ],
18
      },
19
    } satisfies XaiLanguageModelChatOptions,
20
  },
21
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const result = await generateText({
4
  model: xai('grok-3-latest'),
5
  prompt: 'Latest status updates',
6
  providerOptions: {
7
    xai: {
8
      searchParameters: {
9
        mode: 'on',
10
        sources: [
11
          {
12
            type: 'rss',
13
            links: ['https://status.x.ai/feed.xml'],
14
          },
15
        ],
16
      },
17
    } satisfies XaiLanguageModelChatOptions,
18
  },
19
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const result = await generateText({
4
  model: xai('grok-3-latest'),
5
  prompt: 'Comprehensive overview of recent AI breakthroughs',
6
  providerOptions: {
7
    xai: {
8
      searchParameters: {
9
        mode: 'on',
10
        returnCitations: true,
11
        maxSearchResults: 15,
12
        sources: [
13
          {
14
            type: 'web',
15
            allowedWebsites: ['arxiv.org', 'openai.com'],
16
          },
17
          {
18
            type: 'news',
19
            country: 'US',
20
          },
21
          {
22
            type: 'x',
23
            includedXHandles: ['openai', 'deepmind'],
24
          },
25
        ],
26
      },
27
    } satisfies XaiLanguageModelChatOptions,
28
  },
29
});

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2

3
const { text, sources } = await generateText({
4
  model: xai('grok-3-latest'),
5
  prompt: 'What are the latest developments in AI?',
6
  providerOptions: {
7
    xai: {
8
      searchParameters: {
9
        mode: 'auto',
10
        returnCitations: true,
11
      },
12
    } satisfies XaiLanguageModelChatOptions,
13
  },
14
});
15

16
// Access the sources used
17
for (const source of sources) {
18
  if (source.sourceType === 'url') {
19
    console.log('Source:', source.url);
20
  }
21
}

1
import { xai, type XaiLanguageModelChatOptions } from '@ai-sdk/xai';
2
import { streamText } from 'ai';
3

4
const result = streamText({
5
  model: xai('grok-3-latest'),
6
  prompt: 'What has happened in tech recently?',
7
  providerOptions: {
8
    xai: {
9
      searchParameters: {
10
        mode: 'auto',
11
        returnCitations: true,
12
      },
13
    } satisfies XaiLanguageModelChatOptions,
14
  },
15
});
16

17
for await (const textPart of result.textStream) {
18
  process.stdout.write(textPart);
19
}
20

21
console.log('Sources:', await result.sources);

1
import { xai } from '@ai-sdk/xai';
2
import { generateImage } from 'ai';
3

4
const { image } = await generateImage({
5
  model: xai.image('grok-imagine-image'),
6
  prompt: 'A futuristic cityscape at sunset',
7
});

1
import { xai } from '@ai-sdk/xai';
2
import { generateImage } from 'ai';
3
import { readFileSync } from 'fs';
4

5
const imageBuffer = readFileSync('./input-image.png');
6

7
const { images } = await generateImage({
8
  model: xai.image('grok-imagine-image'),
9
  prompt: {
10
    text: 'Turn the cat into a golden retriever dog',
11
    images: [imageBuffer],
12
  },
13
});

1
import { xai } from '@ai-sdk/xai';
2
import { generateImage } from 'ai';
3
import { readFileSync } from 'fs';
4

5
const cat = readFileSync('./cat.png');
6
const dog = readFileSync('./dog.png');
7

8
const { images } = await generateImage({
9
  model: xai.image('grok-imagine-image'),
10
  prompt: {
11
    text: 'Combine these two animals into a group photo',
12
    images: [cat, dog],
13
  },
14
});

1
const imageBuffer = readFileSync('./input-image.png');
2

3
const { images } = await generateImage({
4
  model: xai.image('grok-imagine-image'),
5
  prompt: {
6
    text: 'Transform this into a watercolor painting style',
7
    images: [imageBuffer],
8
  },
9
  aspectRatio: '1:1',
10
});

1
import { xai } from '@ai-sdk/xai';
2
import { generateImage } from 'ai';
3

4
const { images } = await generateImage({
5
  model: xai.image('grok-imagine-image'),
6
  prompt: 'A futuristic cityscape at sunset',
7
  aspectRatio: '16:9',
8
  n: 2,
9
});

1
import { xai, type XaiVideoModelOptions } from '@ai-sdk/xai';
2
import { experimental_generateVideo as generateVideo } from 'ai';
3

4
const { videos } = await generateVideo({
5
  model: xai.video('grok-imagine-video'),
6
  prompt: 'A chicken flying into the sunset in the style of 90s anime.',
7
  aspectRatio: '16:9',
8
  duration: 5,
9
  providerOptions: {
10
    xai: {
11
      pollTimeoutMs: 600000, // 10 minutes
12
    } satisfies XaiVideoModelOptions,
13
  },
14
});

1
import { xai, type XaiVideoModelOptions } from '@ai-sdk/xai';
2
import { experimental_generateVideo as generateVideo } from 'ai';
3

4
const { videos } = await generateVideo({
5
  model: xai.video('grok-imagine-video'),
6
  prompt: {
7
    image: 'https://example.com/start-frame.png',
8
    text: 'The cat slowly turns its head and blinks',
9
  },
10
  duration: 5,
11
  providerOptions: {
12
    xai: {
13
      pollTimeoutMs: 600000, // 10 minutes
14
    } satisfies XaiVideoModelOptions,
15
  },
16
});

1
import { xai, type XaiVideoModelOptions } from '@ai-sdk/xai';
2
import { experimental_generateVideo as generateVideo } from 'ai';
3

4
const { videos } = await generateVideo({
5
  model: xai.video('grok-imagine-video'),
6
  prompt: 'Give the person sunglasses and a hat',
7
  providerOptions: {
8
    xai: {
9
      videoUrl: 'https://example.com/source-video.mp4',
10
      pollTimeoutMs: 600000, // 10 minutes
11
    } satisfies XaiVideoModelOptions,
12
  },
13
});

1
import { xai, type XaiVideoModelOptions } from '@ai-sdk/xai';
2
import { experimental_generateVideo as generateVideo } from 'ai';
3

4
const providerOptions = {
5
  xai: {
6
    videoUrl: 'https://example.com/source-video.mp4',
7
    pollTimeoutMs: 600000,
8
  } satisfies XaiVideoModelOptions,
9
};
10

11
// Step 1: Apply an initial edit
12
const step1 = await generateVideo({
13
  model: xai.video('grok-imagine-video'),
14
  prompt: 'Add a party hat to the person',
15
  providerOptions,
16
});
17

18
// Get the xAI-hosted URL from provider metadata
19
const step1VideoUrl = step1.providerMetadata?.xai?.videoUrl as string;
20

21
// Step 2: Apply two more edits concurrently, building on step 1
22
const [withSunglasses, withScarf] = await Promise.all([
23
  generateVideo({
24
    model: xai.video('grok-imagine-video'),
25
    prompt: 'Add sunglasses',
26
    providerOptions: {
27
      xai: { videoUrl: step1VideoUrl, pollTimeoutMs: 600000 },
28
    },
29
  }),
30
  generateVideo({
31
    model: xai.video('grok-imagine-video'),
32
    prompt: 'Add a scarf',
33
    providerOptions: {
34
      xai: { videoUrl: step1VideoUrl, pollTimeoutMs: 600000 },
35
    },
36
  }),
37
]);