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
const model = xai('grok-3-mini');
2

3
await generateText({
4
  model,
5
  providerOptions: {
6
    xai: {
7
      reasoningEffort: 'high',
8
    },
9
  },
10
});

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

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'),
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'),
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'),
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
import { xai } from '@ai-sdk/xai';
2
import { streamText } from 'ai';
3

4
const { fullStream } = streamText({
5
  model: xai.responses('grok-4-fast'),
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
  },
12
});
13

14
for await (const part of fullStream) {
15
  if (part.type === 'text-delta') {
16
    process.stdout.write(part.text);
17
  } else if (part.type === 'source' && part.sourceType === 'url') {
18
    console.log('\nSource:', part.url);
19
  }
20
}

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

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

1
import { xai } 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
    },
15
  },
16
});
17

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

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

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

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

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

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

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

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

1
import { streamText } from 'ai';
2

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

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

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

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

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

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

4
const { images } = await generateImage({
5
  model: xai.image('grok-2-image'),
6
  prompt: 'A futuristic cityscape at sunset',
7
  maxImagesPerCall: 5, // Default is 10
8
  n: 2, // Generate 2 images
9
});