Live audio transcription with a local open-source stack

Transcribing a meeting while it is happening — from your laptop, a small server under the desk or a headless mini-PC plugged into a USB microphone — used to require a paid cloud service. In 2026, the same workflow runs entirely locally with open-source models and a few Python packages, no quota, no per-minute fee, no audio sent to a third-party server.

This use case focuses on live audio capture from a microphone: meeting notes, interviews, lectures, podcast-style recording, accessibility for hearing-impaired users, voice journaling. The pipeline is straightforward — read audio from the mic, run speech-to-text locally, optionally identify speakers, then optionally hand the transcript to a local LLM for a summary.

Recommended tools in 2026

For a microphone-driven use case, the practical recommendation is Faster-Whisper. It is an open-source reimplementation of OpenAI's Whisper model, built by Guillaume Klein (the author of the CTranslate2 inference engine) to deliver a 4 to 5× speedup and a much lower memory footprint, without changing transcription quality.

A 100% Ollama alternative: Gemma 4

If you want to skip the Python toolchain and stay end-to-end inside Ollama, the gemma4:e2b (6.5 GB) and gemma4:e4b (8.8 GB) variants from Google support audio input natively. Pull the model:

ollama pull gemma4:e4b

Then send the audio file to the Ollama HTTP API in a single request, straight from your terminal with curl — no Python dependency required, just Ollama running locally and the audio to transcribe:

curl http://localhost:11434/api/chat \
  -F "model=gemma4:e4b" \
  -F "messages=[{\"role\":\"user\",\"content\":\"Transcribe this audio.\"}]" \
  -F "images[]=@meeting.mp3"

The JSON response contains the transcript in message.content. To extract the transcript in a readable form straight from the terminal, two options that need only base tools:

With jq (recommended on GNU/Linux, macOS, WSL, Git Bash) — a small dedicated JSON utility, often already installed:

curl -s http://localhost:11434/api/chat \
  -F "model=gemma4:e4b" \
  -F "messages=[{\"role\":\"user\",\"content\":\"Transcribe this audio.\"}]" \
  -F "images[]=@meeting.mp3" \
  | jq -r '.message.content'

Without installing anything at all (pure bash, multi-platform) — regex extraction on the raw JSON:

curl -s http://localhost:11434/api/chat \
  -F "model=gemma4:e4b" \
  -F "messages=[{\"role\":\"user\",\"content\":\"Transcribe this audio.\"}]" \
  -F "images[]=@meeting.mp3" \
  | grep -oE '"content":"[^"]*"' | head -1 | sed 's/^"content":"//; s/"$//'

This second version needs no external tool: grep and sed are present everywhere (GNU/Linux, macOS, and Windows through Git Bash, WSL or MSYS). On Windows CMD or PowerShell without WSL, grep and sed are not native, but you can use PowerShell directly, which knows how to parse JSON without installing anything:

$body = @{
  model = "gemma4:e4b"
  messages = @(@{ role = "user"; content = "Transcribe this audio." })
} | ConvertTo-Json -Compress
Invoke-RestMethod -Method Post -Uri "http://localhost:11434/api/chat" `
  -ContentType "application/json" -Body $body
# Note: PowerShell cannot send a binary file via /api/chat as easily as curl.
# On Windows, the simplest path is to install Git Bash (https://git-scm.com/download/win)
# and use the `curl` + `jq` (or `grep`/`sed`) version above.

Ollama does not need any of these tools: they only format the response for display. If you do not want to install anything, just run the plain curl and copy the text out of the raw JSON output.

If you still prefer to drive Ollama from a Python script, it is just as easy with the official ollama lib:

from ollama import chat

with open("meeting.mp3", "rb") as f:
    audio_bytes = f.read()

response = chat(
    model="gemma4:e4b",
    messages=[{
        "role": "user",
        "content": "Transcribe this audio.",
        "images": [audio_bytes],
    }],
)
print(response.message.content)

On the FLEURS benchmark (multilingual speech recognition), Gemma 4 e4b reaches a 0.08 word error rate, comparable to Whisper-large for most languages.

Trade-offs to know about

• No live streaming : the transcription runs on the whole audio file, not word by word in real time.
• 4B model is less accurate than Faster-Whisper large-v3 on hard cases: strong accents, background noise, rare technical terms.
• No built-in diarization : to identify speakers you still need WhisperX + pyannote (see the paragraph above).

What if my machine is not powerful enough?

gemma4:cloud and gemma4:31b-cloud exist on Ollama Cloud, but those variants do not support audio input (text and image only). For audio transcription, the only option is to run gemma4:e4b or gemma4:e2b locally, which is free and unlimited:

• 16 GB of RAM is enough for e4b in Q4 quantization
• 8 GB of RAM is enough for e2b

For French specifically, Faster-Whisper large-v3 is still the safe choice in 2026. Moonshine is the right pick if you need true streaming, that is, a model that produces the transcript live, word by word or phrase by phrase, with under a second of latency, rather than waiting for the end of a 5-second chunk before showing anything. In practice, Moonshine shines in three cases:

• Live subtitling of a video call or presentation : you want the text to appear on screen while someone is speaking, with no noticeable delay.
• Interactive voice dictation : you dictate and the text appears in your text editor in real time, like a professional dictation tool.
• Accessibility for hearing-impaired users : the transcript has to follow speech at conversation speed, otherwise it loses its usefulness.

In all three cases, Moonshine also uses very little RAM (245 M parameters, runs on a laptop with 8 GB), while Faster-Whisper large-v3 needs 3 to 4 GB of RAM on its own.

Quickstart: from microphone to text in 15 minutes

The shortest path to a working live-transcription tool is Faster-Whisper feeding off the system microphone.

Prerequisites

You need Python 3.9 or newer installed on your system. If you do not have it yet, grab it from the official download page: python.org/downloads. On GNU/Linux it is usually already installed; on macOS and Windows follow the installer.

You also need a working folder to keep the project isolated. The whole tutorial assumes you create a dedicated folder and run every command from inside it.

Set up an isolated Python environment

Once inside your working folder, create a virtual environment so the packages we install do not leak into the rest of your system:

python3 -m venv venv
source venv/bin/activate

From this point on, every pip install you run lives inside this folder. Re-run source venv/bin/activate whenever you open a new terminal and want to come back to the project.

Install the dependencies

# Faster-Whisper for transcription
pip install faster-whisper

# sounddevice + soundfile for microphone I/O
pip install sounddevice soundfile numpy

Minimal live transcription script

import sounddevice as sd
import numpy as np
from faster_whisper import WhisperModel

SAMPLE_RATE = 16000
BLOCK_SECONDS = 5  # transcribe every 5 seconds of audio
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

def callback(indata, frames, time, status):
    if status:
        print(status)
    audio = indata.copy().astype(np.float32).flatten()
    segments, _ = model.transcribe(
        audio,
        language="fr",
        vad_filter=True,
        beam_size=5,
    )
    for segment in segments:
        print(f"[{segment.start:6.1f}s] {segment.text}", flush=True)

with sd.InputStream(
    samplerate=SAMPLE_RATE,
    channels=1,
    dtype="float32",
    blocksize=int(SAMPLE_RATE * BLOCK_SECONDS),
    callback=callback,
):
    print("Listening... press Ctrl+C to stop.")
    sd.sleep(10**9)

Each 5-second block is transcribed on the fly and printed to the console. vad_filter=True (voice activity detection) skips silence so the model is not fed noise when nobody is talking, which both improves accuracy and halves the compute.

To target a specific microphone (a USB conference mic rather than the built-in one), list devices with python -m sounddevice and pass the index:

sd.InputStream(device=2, ...)

To save the transcript to a Markdown file instead of just printing it, write to a handle opened with open("notes.md", "a"). That gives you a living log of the meeting, ready to be passed to a local LLM.

If you need to know who said what (diarization), the reference option is WhisperX paired with pyannote-audio — see their documentation for the setup.

Summarising the transcript with a local LLM

Once the transcript is on disk, a local LLM produces the meeting notes. Ollama is the easiest interface:

The standard prompt, fed with the transcript:

ollama run qwen2.5:7b "Voici la transcription d'une réunion. Produis un compte-rendu structuré en français avec : un résumé exécutif, les décisions prises, et la liste des actions à mener avec un responsable si identifiable. Transcription : $(cat notes.md)"

For English meetings, swap the prompt language and pick an English-tuned model.

Hardware requirements (2026)

The microphone itself matters more than people expect. A USB condenser mic with a cardioid pickup (a Blue Yeti, a Røde NT-USB Mini, a Elgato Wave:1) gives clean signal. The built-in laptop mic picks up the fan and the keyboard and the transcript accuracy drops noticeably.

Microphone-specific tips

A few practical lessons that show up the first time you transcribe a meeting:

• Use a headset or a close-range USB mic. A microphone 50 cm from the speaker gives a much better transcription accuracy than the laptop's built-in mic 1 m away on the desk.
• Enable voice activity detection. vad_filter=True in Faster-Whisper skips non-speech segments, so the model only sees actual words. It also cuts compute roughly in half on a typical meeting.
• Denoise if needed. RNNoise (pip install rnnoise) is a small pre-filter that removes background hiss and fan noise. Run it on the audio buffer before feeding it to Whisper and accuracy climbs another notch on noisy recordings.
• Match the sample rate. Whisper expects 16 kHz mono PCM. Most microphones default to 44.1 or 48 kHz; resample in NumPy before calling transcribe.
• Pick the language explicitly. Pass language="fr" (or "en") instead of letting Whisper auto-detect. Auto-detection eats latency on the first chunk; pinning the language saves a beat on every block.
• Chunk length is a latency knob. 3-second blocks feel almost real-time. 5-second blocks are more accurate. 10-second blocks are best for accuracy but introduce a noticeable delay. Start at 5 and tune.

The verdict

Live audio transcription from a microphone is one of the use cases where local AI is strictly better than the cloud equivalent. Faster-Whisper on a single GPU gives real-time transcription in French and English with the same accuracy as a commercial API, pyannote handles the "who said what" part, and a small local LLM turns the transcript into structured meeting notes. The whole stack is MIT or Apache, fits on a mid-range laptop, and keeps the audio — which often contains the most sensitive content your business handles — on hardware you control.

For a one-off test, the 15-minute quickstart above is enough. For a real workflow that runs every week, set up the live script as a systemd service on an always-on mini-PC, point it at a USB mic on your desk, and pipe the Markdown log to a local LLM at the end of each meeting.