Voxtral-Mini-3B-2507

Voxtral Mini 3B

Audio understanding on a consumer card. Three billion parameters, and the same audio feature set as the model eight times its size.

What Changes at 3B, and What Does Not

The family ships two checkpoints. The difference is narrower than the parameter counts suggest, and it sits in one specific place.

Everything audio is the same. Same transcription mode, same window, same ceilings, same eight languages, same automatic language detection, same ability to trigger functions from speech.

What differs is the language model underneath. Ministral 3B against Mistral Small 3 — the part that reasons about what it heard rather than the part that hears it.

So the question is not "how good is the audio" but "how hard is the question." Transcribe a call: either model. Read the call and judge whether the customer was satisfied: that is a language task, and the backbone is what does it.

Nine and a Half Gigabytes

The number that decides where this model can live.

~9.5 GB in bf16 or fp16 puts it on a single consumer graphics card, and quantised it goes lower still.

What that enables that the larger model does not:

On-device deployment. A laptop, a workstation, a small server — the model sits next to the application rather than behind a network call.

Air-gapped audio. Recordings that cannot leave a building can be processed inside it, on hardware that already exists.

High-volume batch work. Several copies on one machine, or one copy handling far more concurrent requests than a 55 GB model would allow on the same hardware budget.

Edge and embedded contexts, where the model has to run somewhere without a data centre attached.

For audio specifically, that last category matters. Audio is among the most sensitive data most organisations hold — calls, meetings, consultations, interviews — and "it never left the building" is an answer no hosted model can give.

One Model, Not Two

The architectural point, and it applies at either size.

The conventional approach to audio understanding is two models. A speech recogniser converts sound to text; a language model reads the text and answers. Two integrations, two failure modes, and a handover where everything not in the words is discarded — tone, hesitation, overlapping speakers, emphasis.

Voxtral receives the audio. Questions, summaries, and function calls operate on the recording itself.

Mistral's framing: analyse audio and generate structured summaries without the need for separate ASR and language models.

At 3B that consolidation is worth more, not less. A two-model pipeline on constrained hardware means loading two models — and an ASR model plus a small language model may cost more memory together than this one does alone.

Two Modes, Two Endpoints, Two Temperatures

This model lives on two request paths, configured differently.

Mistral publish both settings, and they are not interchangeable. Zero for transcription, where there is one correct answer and variance produces words that were never said. Slightly above zero for understanding, where generating an answer is a different task.

Why the ceilings differ

Same 32k window, different arithmetic.

Transcription emits every word. Half an hour of speech is a great many output tokens, sharing the window with the audio.

Understanding emits an answer. Forty minutes summarised in three hundred tokens leaves far more room for the recording.

The limit is a property of what you ask for, not of the audio. If a recording exceeds the transcription ceiling, ask a question about it instead — which is frequently what you wanted anyway.

Function Calling Straight From Voice

Spoken intent triggers backend functions, workflows, or API calls with no transcription step in between.

Why the missing step matters. A conventional voice pipeline transcribes, parses text for intent, maps intent to a function, extracts arguments, and calls. Each stage loses something. Intent that was obvious from tone survives none of them.

Here the model hears the request and calls the function.

And at 3B this is the capability that makes local voice interfaces practical — a device that listens and acts, with no network round trip and no audio leaving it.

Specifications

Languages: English, Spanish, French, Portuguese, Hindi, German, Dutch, Italian.

Automatic language detection — Voxtral predicts the source language and transcribes accordingly, without being told which.

Capabilities

Multiple audio files per message and multiple user turns with audio are both supported — a conversation can carry several recordings and reference them across turns.

Using Voxtral Mini on DEVUP AI

Two endpoints, two purposes.

Transcription

Endpoint: POST https://api.devupai.com/v1/audio/transcriptions

A multipart form upload. The response carries the transcript text and per-segment timestamps.

curl -X POST "https://api.devupai.com/v1/audio/transcriptions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="mistralai/Voxtral-Mini-3B-2507" \
  -F file=@meeting.mp3

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

with open("meeting.mp3", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="mistralai/Voxtral-Mini-3B-2507",
        file=audio,
        temperature=0.0,
    )

print(result.text)

temperature=0.0 is Mistral's recommendation for this mode. Transcription has one correct answer; sampling variance invents words.

Audio understanding

Endpoint: POST https://api.devupai.com/v1/chat/completions

response = client.chat.completions.create(
    model="mistralai/Voxtral-Mini-3B-2507",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "input_audio", "input_audio": {"data": encoded_audio, "format": "mp3"}},
                {
                    "type": "text",
                    "text": (
                        "What is the caller asking for, and how urgent does it sound? Answer in "
                        "two sentences."
                    ),
                },
            ],
        }
    ],
    temperature=0.2,
    top_p=0.95,
    max_tokens=1024,
)

print(response.choices[0].message.content)

Keep the question narrow on a 3B model. "What is the caller asking for" is a question this model answers well. "Write a full incident report from this call" is a language task where the backbone is the constraint — and the larger model in the family exists for it.

⚠️ How audio is supplied on the chat endpoint varies by platform. Confirm the field shape with a test request before building around it.

Timestamps

Transcription returns per-segment timing, which turns a recording into something searchable.

with open("interview.mp3", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="mistralai/Voxtral-Mini-3B-2507",
        file=audio,
        temperature=0.0,
    )

for segment in result.segments:
    minutes, seconds = divmod(int(segment["start"]), 60)
    print(f"[{minutes:02d}:{seconds:02d}] {segment['text'].strip()}")

Store the timestamps with the text from the start. Recovering them later means re-transcribing, and an archive where a phrase links back to its moment is a different product from a wall of prose.

Batch Transcription

Where a 9.5 GB footprint changes the economics.

from pathlib import Path
import json

RECORDINGS = Path("recordings")
OUTPUT = Path("transcripts")
OUTPUT.mkdir(exist_ok=True)

for path in sorted(RECORDINGS.glob("*.mp3")):
    target = OUTPUT / f"{path.stem}.json"
    if target.exists():
        continue  # already done — do not pay for it twice

    try:
        with path.open("rb") as audio:
            result = client.audio.transcriptions.create(
                model="mistralai/Voxtral-Mini-3B-2507",
                file=audio,
                temperature=0.0,
            )
    except Exception as exc:
        print(f"{path.name}: {type(exc).__name__} — {exc}")
        continue  # one bad file should not stop the run

    target.write_text(
        json.dumps({"text": result.text, "segments": result.segments}, ensure_ascii=False, indent=2),
        encoding="utf-8",
    )
    print(f"{path.name}: {len(result.text)} characters")

The skip-if-exists check is the important line. A run that fails at file 340 of 500 should resume at 341, not start over.

Voice-Triggered Tools

The pattern that makes a local voice interface possible.

import json

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "set_reminder",
            "description": "Create a reminder with a time and a short description.",
            "parameters": {
                "type": "object",
                "properties": {
                    "when": {"type": "string", "description": "ISO 8601 datetime"},
                    "description": {"type": "string"},
                },
                "required": ["when", "description"],
            },
        },
    },
]


def set_reminder(when: str, description: str) -> dict:
    """Replace with your real scheduling backend."""
    raise NotImplementedError


HANDLERS = {"set_reminder": set_reminder}

thread = [
    {
        "role": "system",
        "content": (
            "You handle spoken requests. If the time or the subject of a request is unclear, ask "
            "rather than guessing. Never invent a time the speaker did not give."
        ),
    },
    {
        "role": "user",
        "content": [
            {"type": "input_audio", "input_audio": {"data": encoded_audio, "format": "mp3"}},
        ],
    },
]

CEILING = 6

for step in range(CEILING):
    response = client.chat.completions.create(
        model="mistralai/Voxtral-Mini-3B-2507",
        messages=thread,
        tools=TOOLS,
        temperature=0.2,
        top_p=0.95,
        max_tokens=1024,
    )

    message = response.choices[0].message
    thread.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        thread.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

"Never invent a time the speaker did not give" is the instruction that matters most on a small model. A required argument missing from the speech is a question to ask, not a blank to fill — and a 3B model will fill it if nothing tells it not to.

Validate arguments before dispatch regardless. A reminder set for a time nobody said is a failure that reaches the user rather than your logs.

Preparing Audio

Quality is decided before the request is sent more often than people expect.

Convert to a supported format first. Check which formats your path accepts.

ffmpeg -i recording.m4a -ar 16000 -ac 1 recording.wav

16 kHz mono is the standard working format. Higher sample rates and stereo upload several times the necessary bytes for effectively identical output.

Trim leading and trailing silence. Speech models given nothing to transcribe sometimes produce text that was never spoken.

Split very long recordings at natural pauses. One long upload is a single request that succeeds or fails whole; splitting gives you resumability.

Do not denoise aggressively. Noise reduction tuned for human listening frequently removes information the model uses.

Choosing Between the Two

The decision is about the language task, not the audio one.

Voxtral Mini for transcription at volume, straightforward questions about a recording, voice commands that map to functions, on-device and air-gapped deployment, and anywhere 9.5 GB versus 55 GB is the difference between running and not.

Voxtral Small when the reasoning is the hard part — nuanced analysis of a conversation, structured reports from a long meeting, multi-step judgment about what was said.

A workable split: Mini transcribes and triages everything; Small handles the cases the triage flags as needing judgment. Same feature set on both sides, so the integration is one shape.

Self-Hosting

~9.5 GB of GPU RAM in bf16 or fp16 — a single consumer card, and less when quantised.

vLLM 0.10.0 or later, with Mistral's own tokenizer, config, and load formats rather than the defaults.

mistral_common 1.8.1 or later, installed with audio support — mistral_common[audio]. The audio extra is not optional, and a client missing it fails on the first recording rather than at install time.

Transformers supports Voxtral natively, which is the alternative to the vLLM path.

GGUF builds are published by the community, extending the footprint downward further for CPU and low-memory deployment.

Where It Fits

High-volume transcription, where cost per minute of audio decides whether an archive gets processed at all.

On-device and air-gapped audio, where recordings cannot leave the building — and audio is among the most sensitive data most organisations hold.

Local voice interfaces, with function calling from speech and no network round trip.

Edge and embedded deployment, on hardware without a data centre behind it.

Multilingual audio across eight languages with automatic detection.

Triage in front of a larger model, handling the volume and escalating the hard cases.

Not for complex reasoning about audio. The 3B backbone is the constraint, and the larger model in this family exists for it.

Not for speech generation. It hears; it does not speak.

Not for images. Audio and text only.

Practical Notes

Use temperature 0.0 for transcription and 0.2 with top-p 0.95 for understanding.

Keep understanding questions narrow — that is where a 3B backbone performs best.

Convert to 16 kHz mono before uploading.

Trim silence from both ends.

Store timestamps with transcripts from the start.

Instruct against inventing missing arguments on voice-triggered tools.

Use skip-if-exists on batch runs.

Escalate hard language tasks to the larger model rather than prompting harder here.

Limitations

Three billion parameters of language capability. The audio features match the larger model; the reasoning over what was heard does not.

Two ceilings, not one. Thirty minutes for transcription, forty for understanding.

Eight languages. Others are outside the stated coverage.

No speech output. Audio in, text out.

No image input.

32k context, shared between the audio and everything else in the request.

Speaker identity is not tracked. Diarisation is a separate problem.

Transcription variance is reduced at temperature zero, not eliminated. Store transcripts rather than regenerating them.

Audio leaves your system when uploaded through a hosted path. Recordings routinely contain personal, confidential, or legally sensitive speech — handle them under the same policy you apply to any other outbound data, and more carefully than you would text. Where that policy forbids it entirely, the 9.5 GB footprint is what makes local deployment the answer.

Confident output on unclear audio. A poor recording produces a fluent transcript rather than an obviously degraded one — verify against the audio where accuracy matters.