Skip to main content

​
Overview

The Mistral provider gives you access to Mistral AI’s models for chat completion and embeddings, optimized for European languages and multilingual tasks.

​
Installation

npm install @core-ai/mistral

​
createMistral()

Create a Mistral provider instance. 
import { createMistral } from '@core-ai/mistral';

const mistral = createMistral({
    apiKey: process.env.MISTRAL_API_KEY,
});

​
Options

​
apiKey
string
Your Mistral API key. Defaults to MISTRAL_API_KEY environment variable.
​
baseURL
string
Custom base URL for API requests.
​
client
Mistral
Provide your own configured Mistral client instance.

​
Returns

MistralProvider with methods chatModel() and embeddingModel().

​
Supported models

​
Chat models

  • mistral-large-2512 - Latest flagship model (Mistral Large 3)
  • mistral-large-2407 - Previous generation flagship
  • mistral-medium-2508 - Strong performance at lower cost (Mistral Medium 3.1) - magistral-medium-latest - Reasoning-capable Magistral model
  • mistral-small-2506 - Balanced small model - mistral-small - Quick responses - mistral-tiny - Ultra-fast, lightweight
  • codestral - Optimized for code generation
  • mixtral-8x7b - Mixture of experts architecture
  • mixtral-8x22b - Larger mixture of experts

​
Embedding models

  • mistral-embed - High-quality text embeddings

​
Capabilities

FeatureSupport
Chat CompletionYes
StreamingYes
Function CallingYes
VisionYes
ReasoningOutput only
EmbeddingsYes
Image GenerationNo
Mistral can return reasoning content from thinking-capable models, but it does not map reasoning.effort into the request. The reasoning option is accepted as a no-op. ChatModel.capabilities.reasoning.supported and getMistralModelCapabilities(modelId) both report supported: false with an empty effort list.

​
Examples

​
Basic chat

import { createMistral } from '@core-ai/mistral';
import { generate } from '@core-ai/core-ai';

const mistral = createMistral();

const result = await generate({
    model: mistral.chatModel('mistral-large-2512'),
    messages: [{ role: 'user', content: 'Explain the concept of recursion' }],
});

console.log(result.content);

​
Streaming

import { stream } from '@core-ai/core-ai';

const chatStream = await stream({
    model: mistral.chatModel('mistral-medium-2508'),
    messages: [
        {
            role: 'user',
            content: 'Write a short story about artificial intelligence',
        },
    ],
});

for await (const event of chatStream) {
    if (event.type === 'text-delta') {
        process.stdout.write(event.text);
    }
}

​
Reasoning output

const result = await generate({
    model: mistral.chatModel('magistral-medium-latest'),
    messages: [
        {
            role: 'user',
            content: 'Solve this step by step: if 3x + 7 = 22, what is x?',
        },
    ],
    reasoning: {
        effort: 'high',
    },
});

console.log(result.reasoning);
reasoning.effort is not sent to the Mistral API. Thinking-capable models decide their own reasoning behavior and the adapter extracts the resulting reasoning parts.

​
Tool calling

import { generate, defineTool } from '@core-ai/core-ai';
import { z } from 'zod';

const result = await generate({
    model: mistral.chatModel('mistral-large-2512'),
    messages: [{ role: 'user', content: 'What is 25 multiplied by 4?' }],
    tools: {
        calculator: defineTool({
            name: 'calculator',
            description: 'Perform mathematical calculations',
            parameters: z.object({
                operation: z.enum(['add', 'subtract', 'multiply', 'divide']),
                a: z.number(),
                b: z.number(),
            }),
        }),
    },
});

​
Embeddings

import { embed } from '@core-ai/core-ai';

const result = await embed({
    model: mistral.embeddingModel('mistral-embed'),
    input: 'Search query for semantic similarity',
});

console.log(result.embeddings[0]);

​
Batch embeddings

const documents = ['First document', 'Second document', 'Third document'];

const result = await embed({
    model: mistral.embeddingModel('mistral-embed'),
    input: documents,
});

for (const [i, embedding] of result.embeddings.entries()) {
    console.log(`Document ${i}: ${embedding.length} dimensions`);
}

​
Code generation

const result = await generate({
    model: mistral.chatModel('codestral'),
    messages: [
        {
            role: 'user',
            content:
                'Write a Python function to calculate the Fibonacci sequence using dynamic programming.',
        },
    ],
});

console.log(result.content);

​
Provider-specific options

Options are namespaced under mistral in providerOptions:

​
Generate options

const result = await generate({
    model: mistral.chatModel('mistral-large-2512'),
    messages: [{ role: 'user', content: 'Hello' }],
    providerOptions: {
        mistral: {
            stopSequences: ['\n\n'],
            frequencyPenalty: 0.5,
            presencePenalty: 0.3,
            randomSeed: 42,
            parallelToolCalls: true,
            safePrompt: true,
        },
    },
});
Available fields: stopSequences, frequencyPenalty, presencePenalty, randomSeed, parallelToolCalls, promptMode, safePrompt.
Use parallelToolCalls to enable or disable parallel tool execution when using multiple tools.

​
Embed options

const result = await embed({
    model: mistral.embeddingModel('mistral-embed'),
    input: 'text',
    providerOptions: {
        mistral: {
            encodingFormat: 'float',
        },
    },
});
Available fields: outputDtype ('float' | 'int8' | 'uint8' | 'binary' | 'ubinary'), encodingFormat ('float' | 'base64'), metadata.

​
Error handling

import { ProviderError } from '@core-ai/core-ai';

try {
    const result = await generate({
        model: mistral.chatModel('mistral-large-2512'),
        messages: [{ role: 'user', content: 'Hello!' }],
    });
} catch (error) {
    if (error instanceof ProviderError) {
        console.error('Mistral API error:', error.message);
        console.error('Status:', error.statusCode);
    }
}

OpenAI Provider

GPT models with reasoning effort control

Anthropic Provider

Claude models with extended thinking

Embeddings Guide

Learn how to use embeddings