Moonshot AI Provider

The Moonshot AI provider offers access to powerful language models through the Moonshot API, including the Kimi series of models with reasoning capabilities.

API keys can be obtained from the Moonshot Platform.

Setup

The Moonshot AI provider is available via the @ai-sdk/moonshotai module. You can install it with:

pnpm add @ai-sdk/moonshotai

Provider Instance

You can import the default provider instance moonshotai from @ai-sdk/moonshotai:

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

For custom configuration, you can import createMoonshotAI and create a provider instance with your settings:

1
import { createMoonshotAI } from '@ai-sdk/moonshotai';
2

3
const moonshotai = createMoonshotAI({
4
  apiKey: process.env.MOONSHOT_API_KEY ?? '',
5
});

You can use the following optional settings to customize the Moonshot AI provider instance:

• baseURL string

  Use a different URL prefix for API calls. The default prefix is https://api.moonshot.ai/v1

• apiKey string

  API key that is being sent using the Authorization header. It defaults to the MOONSHOT_API_KEY environment variable

• headers Record<string,string>

  Custom headers to include in the requests

• fetch (input: RequestInfo, init?: RequestInit) => Promise<Response>

  Custom fetch implementation

Language Models

You can create language models using a provider instance:

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

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

You can also use the .chatModel() or .languageModel() factory methods:

1
const model = moonshotai.chatModel('kimi-k2.5');
2
// or
3
const model = moonshotai.languageModel('kimi-k2.5');

Moonshot AI language models can be used in the streamText function (see AI SDK Core).

Reasoning Models

Moonshot AI offers thinking models like kimi-k2-thinking that generate intermediate reasoning tokens before their final response. The reasoning output is streamed through the standard AI SDK reasoning parts.

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

4
const { text, reasoningText } = await generateText({
5
  model: moonshotai('kimi-k2-thinking'),
6
  providerOptions: {
7
    moonshotai: {
8
      thinking: { type: 'enabled', budgetTokens: 2048 },
9
      reasoningHistory: 'interleaved',
10
    } satisfies MoonshotAIProviderOptions,
11
  },
12
  prompt: 'How many "r"s are in the word "strawberry"?',
13
});
14

15
console.log(reasoningText);
16
console.log(text);

See AI SDK UI: Chatbot for more details on how to integrate reasoning into your chatbot.

Provider Options

The following optional provider options are available for Moonshot AI language models:

• thinking object

  Configuration for thinking/reasoning models like Kimi K2 Thinking.

  • type 'enabled' | 'disabled'

    Whether to enable thinking mode

  • budgetTokens number

    Maximum number of tokens for thinking (minimum 1024)

• reasoningHistory 'disabled' | 'interleaved' | 'preserved'

  Controls how reasoning history is handled in multi-turn conversations:

  • 'disabled': Remove reasoning from history
  • 'interleaved': Include reasoning between tool calls within a single turn
  • 'preserved': Keep all reasoning in history

Model Capabilities