Mistral AI Provider

The Mistral AI provider contains language model, embedding model, speech model, and transcription model support for Mistral APIs.

Setup

The Mistral provider is available in the @ai-sdk/mistral module. You can install it with

pnpm add @ai-sdk/mistral

Provider Instance

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

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

If you need a customized setup, you can import createMistral from @ai-sdk/mistral and create a provider instance with your settings:

1
import { createMistral } from '@ai-sdk/mistral';
2

3
const mistral = createMistral({
4
  // custom settings
5
});

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

• baseURL string

  Use a different URL prefix for API calls, e.g. to use proxy servers. The default prefix is https://api.mistral.ai/v1.

• apiKey string

  API key that is being sent using the Authorization header. It defaults to the MISTRAL_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. 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 Mistral chat API using a provider instance. The first argument is the model id, e.g. mistral-large-latest. Some Mistral chat models support tool calls.

1
const model = mistral('mistral-large-latest');

Mistral chat models also support additional model settings that are not part of the standard call settings. You can pass them as an options argument and utilize MistralLanguageModelChatOptions for typing:

1
import { mistral, type MistralLanguageModelChatOptions } from '@ai-sdk/mistral';
2
const model = mistral('mistral-large-latest');
3

4
await generateText({
5
  model,
6
  providerOptions: {
7
    mistral: {
8
      safePrompt: true, // optional safety prompt injection
9
      parallelToolCalls: false, // disable parallel tool calls (one tool per response)
10
    } satisfies MistralLanguageModelChatOptions,
11
  },
12
});

The following optional provider options are available for Mistral models:

• safePrompt boolean

  Whether to inject a safety prompt before all conversations.

  Defaults to false.

• documentImageLimit number

  Maximum number of images to process in a document.

• documentPageLimit number

  Maximum number of pages to process in a document.

• strictJsonSchema boolean

  Whether to use strict JSON schema validation for structured outputs. Only applies when a schema is provided and only sets the strict flag in addition to using Custom Structured Outputs, which is used by default if a schema is provided.

  Defaults to false.

• structuredOutputs boolean

  Whether to use structured outputs. When enabled, tool calls and object generation will be strict and follow the provided schema.

  Defaults to true.

• parallelToolCalls boolean

  Whether to enable parallel function calling during tool use. When set to false, the model will use at most one tool per response.

  Defaults to true.

Document OCR

Mistral chat models support document OCR for PDF files. You can optionally set image and page limits using the provider options.

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

4
const result = await generateText({
5
  model: mistral('mistral-small-latest'),
6
  messages: [
7
    {
8
      role: 'user',
9
      content: [
10
        {
11
          type: 'text',
12
          text: 'What is an embedding model according to this document?',
13
        },
14
        {
15
          type: 'file',
16
          data: new URL(
17
            'https://github.com/vercel/ai/blob/main/examples/ai-functions/data/ai.pdf?raw=true',
18
          ),
19
          mediaType: 'application/pdf',
20
        },
21
      ],
22
    },
23
  ],
24
  // optional settings:
25
  providerOptions: {
26
    mistral: {
27
      documentImageLimit: 8,
28
      documentPageLimit: 64,
29
    } satisfies MistralLanguageModelChatOptions,
30
  },
31
});

Reasoning Models

Mistral offers reasoning models that provide step-by-step thinking capabilities:

• magistral-small-2507: Smaller reasoning model for efficient step-by-step thinking
• magistral-medium-2507: More powerful reasoning model balancing performance and cost

These models return structured reasoning content that the AI SDK extracts automatically. The reasoning is available via the reasoningText property in the result:

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

4
const result = await generateText({
5
  model: mistral('magistral-small-2507'),
6
  prompt: 'What is 15 * 24?',
7
});
8

9
console.log('REASONING:', result.reasoningText);
10
// Output: "Let me calculate this step by step..."
11

12
console.log('ANSWER:', result.text);
13
// Output: "360"

The SDK automatically parses Mistral's native reasoning format and provides separate reasoningText and text properties in the result. No middleware is needed.

Configurable Reasoning

Some Mistral models support configurable reasoning, which you can control via the reasoning parameter. You can use the AI SDK's top-level reasoning setting to control reasoning effort:

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

4
const result = await generateText({
5
  model: mistral('mistral-small-latest'),
6
  reasoning: 'high',
7
  prompt: 'What is 15 * 24?',
8
});
9

10
console.log('REASONING:', result.reasoningText);
11
console.log('ANSWER:', result.text);

So far, Mistral only supports 'high' and 'none' as effort levels.

Example

You can use Mistral language models to generate text with the generateText function:

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

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

Mistral language models can also be used in the streamText function and support structured data generation with Output (see AI SDK Core).

Structured Outputs

Mistral chat models support structured outputs using JSON Schema. You can use generateText or streamText with Output and Zod, Valibot, or raw JSON Schema. The SDK sends your schema via Mistral's response_format: { type: 'json_schema' }.

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

5
const result = await generateText({
6
  model: mistral('mistral-large-latest'),
7
  output: Output.object({
8
    schema: z.object({
9
      recipe: z.object({
10
        name: z.string(),
11
        ingredients: z.array(z.string()),
12
        instructions: z.array(z.string()),
13
      }),
14
    }),
15
  }),
16
  prompt: 'Generate a simple pasta recipe.',
17
});
18

19
console.log(JSON.stringify(result.output, null, 2));

You can enable strict JSON Schema validation using a provider option:

1
import { mistral, type MistralLanguageModelChatOptions } from '@ai-sdk/mistral';
2
import { generateText, Output } from 'ai';
3
import { z } from 'zod';
4

5
const result = await generateText({
6
  model: mistral('mistral-large-latest'),
7
  providerOptions: {
8
    mistral: {
9
      strictJsonSchema: true,
10
    } satisfies MistralLanguageModelChatOptions,
11
  },
12
  output: Output.object({
13
    schema: z.object({
14
      title: z.string(),
15
      items: z.array(
16
        z.object({ id: z.string(), qty: z.number().int().min(1) }),
17
      ),
18
    }),
19
  }),
20
  prompt: 'Generate a small shopping list.',
21
});

Model Capabilities

Transcription Models

You can create models that call the Mistral audio transcription API using the .transcription() factory method:

1
const model = mistral.transcription('voxtral-mini-latest');

Use Mistral transcription models with transcribe:

1
import { mistral } from '@ai-sdk/mistral';
2
import { transcribe } from 'ai';
3
import { readFile } from 'node:fs/promises';
4

5
const result = await transcribe({
6
  model: mistral.transcription('voxtral-mini-latest'),
7
  audio: await readFile('audio.mp3'),
8
});

Mistral transcription models support additional provider options. Pass them through providerOptions.mistral and use MistralTranscriptionModelOptions for type checking:

1
import {
2
  mistral,
3
  type MistralTranscriptionModelOptions,
4
} from '@ai-sdk/mistral';
5
import { transcribe } from 'ai';
6
import { readFile } from 'node:fs/promises';
7

8
const result = await transcribe({
9
  model: mistral.transcription('voxtral-mini-latest'),
10
  audio: await readFile('audio.mp3'),
11
  providerOptions: {
12
    mistral: {
13
      timestampGranularities: ['segment'],
14
      diarize: true,
15
      contextBias: ['Vercel', 'AI_SDK'],
16
    } satisfies MistralTranscriptionModelOptions,
17
  },
18
});

The following optional provider options are available:

• language string

  The language of the audio, such as en. Providing it can improve accuracy.

• temperature number

  The sampling temperature for the transcription.

• timestampGranularities Array<'segment' | 'word'>

  Timestamp granularities to include in the response. Mistral does not support combining this option with language; the SDK throws an InvalidArgumentError when both are provided.

• diarize boolean

  Whether to identify speakers in the transcription.

• contextBias string[]

  Up to 100 words or phrases that guide spelling for names, technical terms, or domain-specific vocabulary. Items cannot contain commas or whitespace; use underscores for multi-word phrases.

The normalized result includes transcript text, language, timed segments, and duration when returned by Mistral. Mistral token and prompt-audio usage is available under result.providerMetadata.mistral.usage. Segment scores and speaker IDs from diarization are available under result.providerMetadata.mistral.segments.

Model Capabilities

Speech Models

You can create models that call the Mistral speech API using the .speech() factory method:

1
const model = mistral.speech('voxtral-mini-tts-2603');

Use a preset or saved voice ID with generateSpeech:

1
import { mistral } from '@ai-sdk/mistral';
2
import { generateSpeech } from 'ai';
3

4
const result = await generateSpeech({
5
  model: mistral.speech('voxtral-mini-tts-2603'),
6
  text: 'Hello from the AI SDK!',
7
  voice: 'en_paul_neutral',
8
  outputFormat: 'mp3',
9
});
10

11
const audio = result.audio.uint8Array;

The Mistral speech model maps voice to Mistral's voice_id. It supports mp3, wav, pcm, flac, and opus output formats and defaults to mp3. The instructions, speed, and language settings are not supported and produce warnings when provided.

Mistral also supports one-off voice cloning with base64-encoded reference audio. Pass it through providerOptions.mistral.refAudio and use MistralSpeechModelOptions for type checking:

1
import { readFile } from 'node:fs/promises';
2
import { mistral, type MistralSpeechModelOptions } from '@ai-sdk/mistral';
3
import { generateSpeech } from 'ai';
4

5
const referenceAudio = await readFile('./reference.mp3');
6

7
const result = await generateSpeech({
8
  model: mistral.speech('voxtral-mini-tts-2603'),
9
  text: 'Hello from the AI SDK!',
10
  providerOptions: {
11
    mistral: {
12
      refAudio: referenceAudio.toString('base64'),
13
    } satisfies MistralSpeechModelOptions,
14
  },
15
});

When refAudio is provided, it takes precedence over voice. Reference audio is redacted from request metadata and API call errors returned by the provider.

Model Capabilities

Embedding Models

You can create models that call the Mistral embeddings API using the .embedding() factory method.

1
const model = mistral.embedding('mistral-embed');

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

1
import { mistral } from '@ai-sdk/mistral';
2
import { embed } from 'ai';
3

4
const { embedding } = await embed({
5
  model: mistral.embedding('codestral-embed-2505'),
6
  value: 'function add(a: number, b: number) { return a + b; }',
7
});

Mistral embedding models support additional provider options through providerOptions.mistral. You can validate them with MistralEmbeddingModelOptions:

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

4
const { embedding } = await embed({
5
  model: mistral.embedding('mistral-embed'),
6
  value: 'sunny day at the beach',
7
  providerOptions: {
8
    mistral: {
9
      metadata: { source: 'knowledge-base' },
10
      outputDimension: 1024,
11
      outputDtype: 'float',
12
    } satisfies MistralEmbeddingModelOptions,
13
  },
14
});

The following optional provider options are available for Mistral embedding models:

• metadata Record<string, unknown>

  Additional metadata to attach to the embedding request.

• outputDimension number

  The dimension of the output embeddings when supported by the model.

• outputDtype string

  The data type of the output embeddings when supported by the model. Accepts 'float', 'int8', 'uint8', 'binary', or 'ubinary'.

Model Capabilities