Alibaba Provider

Alibaba Cloud Model Studio provides access to the Qwen model series, including advanced reasoning capabilities.

API keys can be obtained from the Console.

Setup

The Alibaba provider is available via the @ai-sdk/alibaba module. You can install it with:

pnpm add @ai-sdk/alibaba

Provider Instance

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

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

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

1
import { createAlibaba } from '@ai-sdk/alibaba';
2

3
const alibaba = createAlibaba({
4
  apiKey: process.env.ALIBABA_API_KEY ?? '',
5
});

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

• baseURL string

  Use a different URL prefix for API calls, e.g. to use proxy servers or regional endpoints. The default prefix is https://dashscope-intl.aliyuncs.com/compatible-mode/v1.

• embeddingBaseURL string

  Use a different URL prefix for embedding API calls. The embedding API uses the DashScope native endpoint (not the OpenAI-compatible endpoint). The default prefix is https://dashscope-intl.aliyuncs.com/api/v1.

• apiKey string

  API key that is being sent using the Authorization header. It defaults to the ALIBABA_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.

• includeUsage boolean

  Include usage information in streaming responses. When enabled, token usage will be included in the final chunk. Defaults to true.

Language Models

You can create language models using a provider instance:

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

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

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

1
const model = alibaba.chatModel('qwen-plus');
2
// or
3
const model = alibaba.languageModel('qwen-plus');

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

The following optional provider options are available for Alibaba models:

• enableThinking boolean

  Enable thinking/reasoning mode for supported models. When enabled, the model generates reasoning content before the response. Defaults to false.

• thinkingBudget number

  Maximum number of reasoning tokens to generate. Limits the length of thinking content.

• parallelToolCalls boolean

  Whether to enable parallel function calling during tool use. Defaults to true.

Thinking Mode

Alibaba's Qwen models support thinking/reasoning mode for complex problem-solving:

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

4
const { text, reasoning } = await generateText({
5
  model: alibaba('qwen3-max'),
6
  providerOptions: {
7
    alibaba: {
8
      enableThinking: true,
9
      thinkingBudget: 2048,
10
    },
11
  },
12
  prompt: 'How many "r"s are in the word "strawberry"?',
13
});
14

15
console.log('Reasoning:', reasoning);
16
console.log('Answer:', text);

For models that are thinking-only (like qwen3-235b-a22b-thinking-2507), thinking mode is enabled by default.

Tool Calling

Alibaba models support tool calling with parallel execution:

1
import { alibaba } from '@ai-sdk/alibaba';
2
import { generateText, tool } from 'ai';
3
import { z } from 'zod';
4

5
const { text } = await generateText({
6
  model: alibaba('qwen-plus'),
7
  tools: {
8
    weather: tool({
9
      description: 'Get the weather in a location',
10
      parameters: z.object({
11
        location: z.string().describe('The location to get the weather for'),
12
      }),
13
      execute: async ({ location }) => ({
14
        location,
15
        temperature: 72 + Math.floor(Math.random() * 21) - 10,
16
      }),
17
    }),
18
  },
19
  prompt: 'What is the weather in San Francisco?',
20
});

Prompt Caching

Alibaba supports both implicit and explicit prompt caching to reduce costs for repeated prompts.

Implicit caching works automatically - the provider caches appropriate content without any configuration. For more control, you can use explicit caching by marking specific messages with cache_control:

Single message cache control

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

4
const { text, usage } = await generateText({
5
  model: alibaba('qwen-plus'),
6
  messages: [
7
    {
8
      role: 'system',
9
      content: 'You are a helpful assistant. [... long system prompt ...]',
10
      providerOptions: {
11
        alibaba: {
12
          cache_control: { type: 'ephemeral' },
13
        },
14
      },
15
    },
16
  ],
17
});

Multi-part message cache control

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

4
const longDocument = '... large document content ...';
5

6
const { text, usage } = await generateText({
7
  model: alibaba('qwen-plus'),
8
  messages: [
9
    {
10
      role: 'user',
11
      content: [
12
        {
13
          type: 'text',
14
          text: 'Context: Please analyze this document.',
15
        },
16
        {
17
          type: 'text',
18
          text: longDocument,
19
          providerOptions: {
20
            alibaba: {
21
              cacheControl: { type: 'ephemeral' },
22
            },
23
          },
24
        },
25
      ],
26
    },
27
  ],
28
});

Note: The minimum content length for a cache block is 1,024 tokens.

Embedding Models

You can create text embedding models using the .textEmbeddingModel() factory method. For more on embeddings with the AI SDK see embed() and embedMany().

1
const model = alibaba.textEmbeddingModel('text-embedding-v4');

You can use Alibaba embedding models to generate embeddings with the embed function:

1
import { alibaba, type AlibabaEmbeddingModelOptions } from '@ai-sdk/alibaba';
2
import { embed } from 'ai';
3

4
const { embedding, usage } = await embed({
5
  model: alibaba.textEmbeddingModel('text-embedding-v4'),
6
  value: 'sunny day at the beach',
7
  providerOptions: {
8
    alibaba: {
9
      textType: 'document',
10
      dimension: 1024,
11
      outputType: 'dense',
12
    } satisfies AlibabaEmbeddingModelOptions,
13
  },
14
});

Use embedMany to embed multiple text values. Alibaba text embedding models support up to 10 values per API call; larger batches are split automatically by embedMany.

1
import { alibaba, type AlibabaEmbeddingModelOptions } from '@ai-sdk/alibaba';
2
import { embedMany } from 'ai';
3

4
const { embeddings } = await embedMany({
5
  model: alibaba.textEmbeddingModel('text-embedding-v4'),
6
  values: [
7
    'sunny day at the beach',
8
    'rainy afternoon in the city',
9
    'snowy night in the mountains',
10
  ],
11
  providerOptions: {
12
    alibaba: {
13
      textType: 'document',
14
      dimension: 1024,
15
    } satisfies AlibabaEmbeddingModelOptions,
16
  },
17
});

Alibaba embedding models support additional provider options that can be passed via providerOptions.alibaba:

• textType 'query' | 'document'

  Differentiates query text from document text for asymmetric retrieval tasks. Defaults to document.

• dimension number

  The dimension of the output embedding vectors. Defaults to 1024. text-embedding-v4 also supports 1536 and 2048 dimensions.

• outputType 'dense' | 'sparse' | 'dense&sparse'

  Specifies the output vector type. Defaults to dense. The AI SDK embedding interface returns dense number[] vectors, so sparse-only output is not supported and will throw. Use dense&sparse to receive dense embeddings in embedding/embeddings and sparse vectors in providerMetadata.alibaba.sparseEmbeddings.

Embedding Model Capabilities

Model Capabilities

Please see the Alibaba Cloud Model Studio docs for a full list of available models. You can also pass any available provider model ID as a string if needed.