Mimi

Mimi

A neural audio codec from Kyutai that squeezes speech into compact audio tokens and decodes them back. It suits researchers and developers building speech language models or text-to-speech systems.

Made by kyutai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Mimi is a neural audio codec from Kyutai. It turns speech into a stream of audio tokens at 12.5 Hz, using a bitrate of 1.1 kbps, and can decode those tokens back into sound. The tokens carry both meaning and acoustic detail. The model has 96.2 million parameters and was trained end to end on speech.

Who it suits: It suits people working on speech language models or voice synthesis tools, since the card says it was trained on speech with such work in mind. It also fits developers who need real-time compression of voice audio.

Title: Who might use it
Industry | Who uses it | How they use it | Example
AI research | Speech model researchers | Use audio tokens as the units a speech model reads and writes | Encode a clip into codes, then decode the codes back to audio
Voice products | Text-to-speech engineers | Compress and restore speech as a streaming step | Run a codec round trip before wiring it into a pipeline
Software | Python developers | Try the codec through the transformers library | Run the card's sample on a short LibriSpeech clip

If you work with music or general sound, you can skip it, because the card lists speech as its audio type.

Where to use it: Python with the transformers library is the main route. The card also points to Moshi, Kyutai's own speech system, for another way to use it.

• Python with the transformers library
• Moshi, Kyutai's speech-text system, which has its own readme
• Windows, macOS or Linux with Python, to download the files

Title: Jobs it does
Use case | Who | What they get back
Encode speech | Researchers | A short sequence of audio codes for a clip
Decode codes | Developers | A waveform rebuilt from those codes
Real-time speech compression | Audio engineers | Smaller speech data with efficient decoding

How to set it up: You need Python and pip. The card's sample also uses the datasets library with its audio extras and a development build of transformers.

• Python with pip
• The datasets library with audio support
• The development version of transformers from its main branch

1. Upgrade pip and install datasets with its audio extras.
2. Install transformers from its GitHub main branch, as the card describes.
3. Optionally fetch the model files with the Hugging Face tools.

pip install --upgrade pip
pip install --upgrade datasets[audio]

pip install -U huggingface_hub
hf download kyutai/mimi

How to use it: Load a short test clip, prepare it with the feature extractor, then encode it into audio codes and decode them back. You can also call the model once and read the audio values from the result.

from datasets import load_dataset, Audio
from transformers import MimiModel, AutoFeatureExtractor

# load a demonstration datasets
librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

# load the model + feature extractor (for pre-processing the audio)
model = MimiModel.from_pretrained("kyutai/mimi")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/mimi")

# cast the audio data to the correct sampling rate for the model
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[0]["audio"]["array"]

# pre-process the inputs
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt")

# explicitly encode then decode the audio inputs
encoder_outputs = model.encode(inputs["input_values"])
audio_values = model.decode(encoder_outputs.audio_codes)[0]

# or the equivalent with a forward pass
audio_values = model(inputs["input_values"]).audio_values

Title: Main calls
Tool | What it does
MimiModel.from_pretrained | Loads the codec by its name
AutoFeatureExtractor | Prepares raw audio at the sampling rate the model expects
model.encode | Turns the prepared audio into audio codes
model.decode | Rebuilds audio values from those codes

Example: You load the small LibriSpeech test clip, prepare it, and call encode. You get audio codes for the clip. Passing them to decode returns audio values you can compare with the original recording.

For newcomers and experts: If you are new, think of a codec as a compact way to store a voice recording as a short list of numbers. The first thing to try is the card's sample script on its small test clip.

If you know the field, Mimi is a streaming encoder-decoder with a quantized latent space, trained end to end. It mixes semantic and acoustic information in one token stream at a low frame rate. That trades some fidelity for tokens a language model can handle, and the training data was speech only.

A speech clip goes in
The feature extractor prepares the audio
The encoder makes audio codes
The decoder rebuilds the audio

Good to know: The weights are small by model standards. The 4-bit figure is an estimate from the Hugging Face record, not a file you download.

Title: Approximate weight size
F32: 385 MB
4-bit estimate: 48 MB

• License: CC-BY 4.0
• Cost to run: none named
• Data it reaches: the model files from Hugging Face, plus the small LibriSpeech sample the card loads
• Not for: impersonating other people or any malicious use, and the card admits some bias toward topics common in its training data

On Hugging Face, 13 November 2026

• Task: feature extraction
• Library: transformers
• Parameters: 96.2M
• Weights: about 385 MB in F32; about 48 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 133,933
• Likes: 345
• License: cc-by-4.0
• Quantized versions: 5
• Fine-tunes: 5
• Tags: transformers, safetensors, mimi, feature-extraction, audio

Links

• Model: https://huggingface.co/kyutai/mimi
• Files: https://huggingface.co/kyutai/mimi/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download kyutai/mimi

Then follow the usage in its model card. Nothing in this kit runs by itself.