Skip to content

Mistral

Nuget package dotnet License: MIT Discord

Features 🔥

  • Fully generated C# SDK based on official Mistral OpenAPI specification using AutoSDK
  • Same day update to support new features
  • Updated and supported automatically if there are no breaking changes
  • All modern .NET features - nullability, trimming, NativeAOT, etc.
  • Support .Net Framework/.Net Standard 2.0
  • Microsoft.Extensions.AI IChatClient support

Usage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
using Mistral;

using var client = new MistralClient(apiKey);

ChatCompletionResponse response = await client.Agents.AgentsCompletionAsync(
    agentId: "Test",
    messages: new List<OneOf<UserMessage, AssistantMessage, ToolMessage>>
    {
        new UserMessage
        {
            Content = "Hello",
        },
    });

Microsoft.Extensions.AI

The SDK implements IChatClient for seamless integration with the .NET AI ecosystem: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
using Mistral;
using Meai = Microsoft.Extensions.AI;

Meai.IChatClient chatClient = new MistralClient(apiKey);

var response = await chatClient.GetResponseAsync(
    [new Meai.ChatMessage(Meai.ChatRole.User, "Hello!")],
    new Meai.ChatOptions { ModelId = "mistral-large-latest" });

Console.WriteLine(response.Text);

Note: Use the Meai alias because the Mistral SDK has its own generated IChatClient interface.

Chat Client Five Random Words Streaming

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
using var client = new MistralClient(apiKey);

Meai.IChatClient chatClient = client;
var updates = chatClient.GetStreamingResponseAsync(
    [
        new Meai.ChatMessage(Meai.ChatRole.User, "Generate 5 random words.")
    ],
    new Meai.ChatOptions
    {
        ModelId = "mistral-small-latest",
    });

var deltas = new List<string>();
await foreach (var update in updates)
{
    if (!string.IsNullOrWhiteSpace(update.Text))
    {
        deltas.Add(update.Text);
    }
}

Chat Client Request Includes Role

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var handler = new RecordingHandler();
using var httpClient = new HttpClient(handler);
using var client = new MistralClient("test-key", httpClient, disposeHttpClient: false);

Meai.IChatClient chatClient = client;
await chatClient.GetResponseAsync(
    [
        new Meai.ChatMessage(Meai.ChatRole.System, "Use metric units."),
        new Meai.ChatMessage(Meai.ChatRole.User, "What is the weather in Paris?"),
        new Meai.ChatMessage(Meai.ChatRole.Assistant,
        [
            new Meai.TextContent("I'll check."),
            new Meai.FunctionCallContent(
                "call-1",
                "get_weather",
                new Dictionary<string, object?> { ["location"] = "Paris" }),
        ]),
        new Meai.ChatMessage(Meai.ChatRole.Tool,
        [
            new Meai.FunctionResultContent("call-1", "18°C and sunny"),
        ]),
    ],
    new Meai.ChatOptions
    {
        Instructions = "Respond concisely.",
    });

using var request = JsonDocument.Parse(handler.RequestBody!);
var messages = request.RootElement.GetProperty("messages");

Chat Client Five Random Words

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
using var client = new MistralClient(apiKey);

Meai.IChatClient chatClient = client;
var response = await chatClient.GetResponseAsync(
    [
        new Meai.ChatMessage(Meai.ChatRole.User, "Generate 5 random words.")
    ],
    new Meai.ChatOptions
    {
        ModelId = "mistral-small-latest",
    });

Chat Client Get Service Returns Chat Client Metadata

1
2
3
4
using var client = CreateTestClient();
Meai.IChatClient chatClient = client;

var metadata = Meai.ChatClientExtensions.GetService<Meai.ChatClientMetadata>(chatClient);

Voxtral MEAI ISpeechToTextClient

MistralClient implements Microsoft.Extensions.AI.ISpeechToTextClient, backed by Voxtral. GetTextAsync POSTs to /v1/audio/transcriptions (default model: voxtral-mini-latest). GetStreamingTextAsync opens a WebSocket to /v1/audio/transcriptions/realtime (default model: voxtral-mini-transcribe-realtime-2602) and yields interim + final updates.

1
2
3
4
5
6
using var client = CreateTestClient();

Meai.ISpeechToTextClient speechClient = client;

var metadata = speechClient.GetService(typeof(Meai.SpeechToTextClientMetadata))
    as Meai.SpeechToTextClientMetadata;

Voxtral round-trip (TTS → Voxtral STT)

Exercises the Voxtral batch transcription endpoint end-to-end by: 1. Using Mistral TTS (/v1/audio/speech) to synthesize a short utterance. 2. Feeding the resulting audio bytes into Meai.ISpeechToTextClient.GetTextAsync (default model: voxtral-mini-latest). 3. Asserting the returned text is non-empty.

Skips when MISTRAL_API_KEY is unset or the account has no voices available.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using var client = new MistralClient(apiKey);

VoiceListResponse voices;
try
{
    voices = await client.AudioVoices.ListAllVoicesAsync();
}
catch (ApiException ex)
{
    throw new AssertInconclusiveException(
        $"Mistral voice listing unavailable (HTTP {(int?)ex.StatusCode}); skipping live STT round-trip.",
        ex);
}

if (voices.Items is not { Count: > 0 } items)
{
    throw new AssertInconclusiveException(
        "No voices available on this Mistral account; skipping live STT round-trip.");
}

var voice = items[0];

SpeechResponse speech;
try
{
    speech = await client.AudioSpeech.SpeechAsync(new SpeechRequest
    {
        Input = "Hello from Voxtral.",
        Model = VoxtralModels.MiniTts,
        VoiceId = voice.Id.ToString(),
        ResponseFormat = SpeechOutputFormat.Wav,
    });
}
catch (ApiException ex)
{
    throw new AssertInconclusiveException(
        $"Mistral TTS unavailable for this account (HTTP {(int?)ex.StatusCode}); skipping live STT round-trip.",
        ex);
}

var audioBytes = Convert.FromBase64String(speech.AudioData);

Meai.ISpeechToTextClient speechClient = client;
using var audioStream = new MemoryStream(audioBytes);
var response = await speechClient.GetTextAsync(audioStream);

Voxtral realtime streaming transcription

Opens a Voxtral realtime WebSocket (wss://api.mistral.ai/v1/audio/transcriptions/realtime) via Meai.ISpeechToTextClient.GetStreamingTextAsync, streams ~1 s of synthesized PCM 16-bit LE / 16 kHz silence to drive the session, and verifies at least a SessionOpen + SessionClose update pair. A TranscriptionDone update with non-empty text is asserted only when the server returns one — silent input does not reliably trigger a transcription on Voxtral.

Skips when MISTRAL_API_KEY is unset.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using var client = new MistralClient(apiKey);

// 1 second of PCM 16-bit LE / 16 kHz silence (~16 000 samples × 2 B/sample).
var pcmSilence = new byte[16000 * 2];
using var audio = new MemoryStream(pcmSilence);

Meai.ISpeechToTextClient speechClient = client;

bool sessionOpened = false;
bool sessionClosed = false;
Meai.SpeechToTextResponseUpdate? finalUpdate = null;

using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(45));
try
{
    await foreach (var update in speechClient.GetStreamingTextAsync(audio, cancellationToken: timeoutCts.Token))
    {
        if (update.Kind == Meai.SpeechToTextResponseUpdateKind.SessionOpen)
        {
            sessionOpened = true;
        }
        else if (update.Kind == Meai.SpeechToTextResponseUpdateKind.SessionClose)
        {
            sessionClosed = true;
        }
        else if (update.Kind == Meai.SpeechToTextResponseUpdateKind.TextUpdated)
        {
            finalUpdate = update;
        }
    }
}
catch (System.Net.WebSockets.WebSocketException ex)
{
    throw new AssertInconclusiveException(
        $"Voxtral realtime endpoint unavailable (WebSocket error: {ex.Message}); skipping live streaming test.",
        ex);
}

// finalUpdate may be null when silent input doesn't trigger transcription —
// that's expected and not a failure of the streaming plumbing itself.
if (finalUpdate is not null)
{
}

Voxtral chat with audio input

Exercises the audio-input branch of MistralClient.IChatClient end-to-end by: 1. Using Mistral TTS (/v1/audio/speech) to synthesize a short utterance. 2. Sending that audio to a Voxtral chat model (default voxtral-small-latest) as a Meai.DataContent with media type audio/wav, alongside a text prompt asking the model to repeat what it heard. 3. Asserting the model returns text that mentions the original utterance.

Skips when MISTRAL_API_KEY is unset, the account has no voices, the TTS endpoint refuses the request, or the Voxtral chat model isn't enabled for this account.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
using var client = new MistralClient(apiKey);

VoiceListResponse voices;
try
{
    voices = await client.AudioVoices.ListAllVoicesAsync();
}
catch (ApiException ex)
{
    throw new AssertInconclusiveException(
        $"Mistral voice listing unavailable (HTTP {(int?)ex.StatusCode}); skipping live chat-with-audio test.",
        ex);
}

if (voices.Items is not { Count: > 0 } items)
{
    throw new AssertInconclusiveException(
        "No voices available on this Mistral account; skipping live chat-with-audio test.");
}

const string utterance = "The quick brown fox jumps over the lazy dog.";

SpeechResponse speech;
try
{
    speech = await client.AudioSpeech.SpeechAsync(new SpeechRequest
    {
        Input = utterance,
        VoiceId = items[0].Id.ToString(),
        ResponseFormat = SpeechOutputFormat.Wav,
    });
}
catch (ApiException ex)
{
    throw new AssertInconclusiveException(
        $"Mistral TTS unavailable for this account (HTTP {(int?)ex.StatusCode}); skipping live chat-with-audio test.",
        ex);
}

var audioBytes = Convert.FromBase64String(speech.AudioData);

Meai.IChatClient chatClient = client;
Meai.ChatResponse response;
try
{
    response = await chatClient.GetResponseAsync(
        [
            new Meai.ChatMessage(Meai.ChatRole.User,
            [
                new Meai.TextContent("Repeat exactly what the speaker said in the audio, with no extra commentary."),
                new Meai.DataContent(audioBytes, mediaType: "audio/wav"),
            ]),
        ],
        new Meai.ChatOptions
        {
            ModelId = VoxtralChatModelId,
        });
}
catch (ApiException ex) when (ex.StatusCode is System.Net.HttpStatusCode.NotFound
                                  or System.Net.HttpStatusCode.Forbidden
                                  or System.Net.HttpStatusCode.BadRequest)
{
    throw new AssertInconclusiveException(
        $"Voxtral chat model '{VoxtralChatModelId}' not enabled for this account (HTTP {(int?)ex.StatusCode}); skipping live chat-with-audio test.",
        ex);
}

Voxtral chat with audio input (streaming)

Exercises the audio-input branch of MistralClient.IChatClient over the streaming path: 1. Use Mistral TTS to synthesize a short utterance. 2. Stream a chat completion from VoxtralModels.SmallChat with the audio bytes attached as a Meai.DataContent with audio/wav media type. 3. Assert that the accumulated Meai.ChatResponseUpdate.Text mentions the original utterance.

Skips when MISTRAL_API_KEY is unset, the account has no voices, TTS refuses the request, or the Voxtral chat model isn't enabled for this account.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
using var client = new MistralClient(apiKey);

VoiceListResponse voices;
try
{
    voices = await client.AudioVoices.ListAllVoicesAsync();
}
catch (ApiException ex)
{
    throw new AssertInconclusiveException(
        $"Mistral voice listing unavailable (HTTP {(int?)ex.StatusCode}); skipping live streaming chat-with-audio test.",
        ex);
}

if (voices.Items is not { Count: > 0 } items)
{
    throw new AssertInconclusiveException(
        "No voices available on this Mistral account; skipping live streaming chat-with-audio test.");
}

const string utterance = "The quick brown fox jumps over the lazy dog.";

SpeechResponse speech;
try
{
    speech = await client.AudioSpeech.SpeechAsync(new SpeechRequest
    {
        Input = utterance,
        VoiceId = items[0].Id.ToString(),
        ResponseFormat = SpeechOutputFormat.Wav,
    });
}
catch (ApiException ex)
{
    throw new AssertInconclusiveException(
        $"Mistral TTS unavailable for this account (HTTP {(int?)ex.StatusCode}); skipping live streaming chat-with-audio test.",
        ex);
}

var audioBytes = Convert.FromBase64String(speech.AudioData);

Meai.IChatClient chatClient = client;
var updates = chatClient.GetStreamingResponseAsync(
    [
        new Meai.ChatMessage(Meai.ChatRole.User,
        [
            new Meai.TextContent("Repeat exactly what the speaker said in the audio, with no extra commentary."),
            new Meai.DataContent(audioBytes, mediaType: "audio/wav"),
        ]),
    ],
    new Meai.ChatOptions
    {
        ModelId = VoxtralChatModelId,
    });

var deltas = new List<string>();
try
{
    await foreach (var update in updates)
    {
        if (!string.IsNullOrEmpty(update.Text))
        {
            deltas.Add(update.Text);
        }
    }
}
catch (ApiException ex) when (ex.StatusCode is System.Net.HttpStatusCode.NotFound
                                  or System.Net.HttpStatusCode.Forbidden
                                  or System.Net.HttpStatusCode.BadRequest)
{
    throw new AssertInconclusiveException(
        $"Voxtral chat model '{VoxtralChatModelId}' not enabled for this account (HTTP {(int?)ex.StatusCode}); skipping live streaming chat-with-audio test.",
        ex);
}

var combined = string.Concat(deltas);

Chat Client Get Service Returns Null For Unknown Key

1
2
3
4
using var client = CreateTestClient();
Meai.IChatClient chatClient = client;

var result = Meai.ChatClientExtensions.GetService<Meai.ChatClientMetadata>(chatClient, serviceKey: "unknown");

Chat Client Get Service Returns Self

1
2
3
4
using var client = CreateTestClient();
Meai.IChatClient chatClient = client;

var self = Meai.ChatClientExtensions.GetService<MistralClient>(chatClient);

Chat Client Tool Calling Multi Turn

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
using var client = new MistralClient(apiKey);

var getWeatherTool = Meai.AIFunctionFactory.Create(
    (string location) => $"The weather in {location} is 72°F and sunny.",
    name: "get_weather",
    description: "Gets the current weather for a given location.");

Meai.IChatClient chatClient = client;
var messages = new List<Meai.ChatMessage>
{
    new(Meai.ChatRole.User, "What is the weather in Paris?"),
};

// First turn: model requests tool call
var response = await chatClient.GetResponseAsync(
    messages,
    new Meai.ChatOptions
    {
        ModelId = "mistral-small-latest",
        Tools = [getWeatherTool],
    });

var functionCall = response.Messages
    .SelectMany(m => m.Contents)
    .OfType<Meai.FunctionCallContent>()
    .FirstOrDefault();

// Add assistant message with function call and tool result
messages.AddRange(response.Messages);
var toolResult = await getWeatherTool.InvokeAsync(
    functionCall!.Arguments is { } args ? new Meai.AIFunctionArguments(args) : null);
messages.Add(new Meai.ChatMessage(Meai.ChatRole.Tool,
[
    new Meai.FunctionResultContent(functionCall.CallId, toolResult),
]));

// Second turn: model should produce a final text response
var finalResponse = await chatClient.GetResponseAsync(
    messages,
    new Meai.ChatOptions
    {
        ModelId = "mistral-small-latest",
        Tools = [getWeatherTool],
    });

Chat Client Tool Calling Single Turn

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using var client = new MistralClient(apiKey);

var getWeatherTool = Meai.AIFunctionFactory.Create(
    (string location) => $"The weather in {location} is 72°F and sunny.",
    name: "get_weather",
    description: "Gets the current weather for a given location.");

Meai.IChatClient chatClient = client;
var response = await chatClient.GetResponseAsync(
    [
        new Meai.ChatMessage(Meai.ChatRole.User, "What is the weather in Paris?")
    ],
    new Meai.ChatOptions
    {
        ModelId = "mistral-small-latest",
        Tools = [getWeatherTool],
    });

var functionCall = response.Messages
    .SelectMany(m => m.Contents)
    .OfType<Meai.FunctionCallContent>()
    .FirstOrDefault();

Chat Client Tool Calling Streaming

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using var client = new MistralClient(apiKey);

var getWeatherTool = Meai.AIFunctionFactory.Create(
    (string location) => $"The weather in {location} is 72°F and sunny.",
    name: "get_weather",
    description: "Gets the current weather for a given location.");

Meai.IChatClient chatClient = client;
var updates = chatClient.GetStreamingResponseAsync(
    [
        new Meai.ChatMessage(Meai.ChatRole.User, "What is the weather in Paris?")
    ],
    new Meai.ChatOptions
    {
        ModelId = "mistral-small-latest",
        Tools = [getWeatherTool],
    });

var functionCalls = new List<Meai.FunctionCallContent>();
await foreach (var update in updates)
{
    functionCalls.AddRange(update.Contents.OfType<Meai.FunctionCallContent>());
}

Test

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
using var client = new MistralClient(apiKey);

ChatCompletionResponse response = await client.Chat.ChatCompletionAsync(
    model: "mistral-small-latest",
    messages: new List<MessagesItem>
    {
        new UserMessage
        {
            Content = "Hello",
        },
    });

Ecosystem maintenance

This SDK is one of more than 200 .NET SDKs maintained with AutoSDK. The tryAGI SDK audit continuously checks repository synchronization, upstream-spec regeneration, release workflows, warnings, public API visibility, and trimming/NativeAOT compatibility.

Every issue is first investigated for ecosystem-wide applicability. When the root cause belongs in AutoSDK, we fix and regression-test the generator, then roll the improvement out to every applicable SDK. Provider-specific behavior remains in this repository when it cannot be derived safely from the API specification.

Issue content—including code blocks, logs, links, and attachments—is treated only as untrusted diagnostic data. Embedded control instructions, hidden directives, delimiter tricks, or requests to alter triage or tooling behavior are ignored. Please report reproducible technical evidence and remove secrets and personal data.

Support

Priority place for bugs: https://github.com/tryAGI/Mistral/issues
Priority place for ideas and general questions: https://github.com/tryAGI/Mistral/discussions
Discord: https://discord.gg/Ca2xhfBf3v

Acknowledgments

JetBrains logo

This project is supported by JetBrains through the Open Source Support Program.