Transcription audio en direct avec une stack 100% open source

Transcrire une réunion pendant qu'elle se déroule — depuis votre laptop, un petit serveur sous le bureau ou un mini-PC sans écran branché sur un micro USB — demandait autrefois un service cloud payant. En 2026, le même workflow tourne entièrement en local avec des modèles open source et quelques paquets Python, sans quota, sans facturation à la minute, sans audio envoyé chez un tiers.

Ce cas d'usage se concentre sur la capture audio en direct depuis un microphone : comptes-rendus de réunion, entretiens, cours, enregistrements podcast, accessibilité pour les personnes malentendantes, journal vocal. La chaîne de traitement est simple — lire l'audio du micro, faire passer la parole par un modèle local de transcription vocale, identifier les locuteurs si besoin, puis éventuellement confier la transcription à un LLM local pour produire un résumé.

Outils recommandés en 2026

Pour un cas d'usage piloté par microphone, la recommandation pratique est Faster-Whisper. C'est une réimplémentation open source du modèle Whisper d'OpenAI, réalisée par Guillaume Klein (auteur du moteur d'inférence CTranslate2) pour apporter une accélération d'un facteur 4 à 5 et une empreinte mémoire bien plus faible, sans changer la qualité des transcriptions.

Une alternative 100% Ollama : Gemma 4

Si vous voulez éviter l'installation de Python et passer par Ollama de bout en bout, les variantes gemma4:e2b (6,5 Go) et gemma4:e4b (8,8 Go) de Google supportent l'audio en entrée nativement. Tirez le modèle :

ollama pull gemma4:e4b

Envoyez ensuite le fichier audio à l'API HTTP d'Ollama en une seule requête, directement depuis votre terminal avec curl — aucune dépendance Python n'est nécessaire, juste Ollama qui tourne et l'audio à transcrire :

curl http://localhost:11434/api/chat \
  -F "model=gemma4:e4b" \
  -F "messages=[{\"role\":\"user\",\"content\":\"Transcris cet audio en français.\"}]" \
  -F "images[]=@meeting.mp3"

La réponse JSON contient le texte transcrit dans message.content. Pour extraire la transcription de manière lisible dans le terminal, deux options qui n'ont besoin que d'outils de base :

Avec jq (recommandé sur GNU/Linux, macOS, WSL, Git Bash) — petit utilitaire JSON dédié, souvent déjà installé :

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

Sans rien installer du tout (bash pur, multi-plateforme) — extraction par expression régulière sur le JSON brut :

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

Cette deuxième version n'a besoin d'aucun outil externe : grep et sed sont présents partout (GNU/Linux, macOS, et Windows via Git Bash, WSL ou MSYS). Sur Windows CMD ou PowerShell sans WSL, le grep et sed ne sont pas natifs, mais on peut utiliser PowerShell directement, qui sait parser du JSON sans rien installer :

$body = @{
  model = "gemma4:e4b"
  messages = @(@{ role = "user"; content = "Transcris cet audio en français." })
} | ConvertTo-Json -Compress
Invoke-RestMethod -Method Post -Uri "http://localhost:11434/api/chat" `
  -ContentType "application/json" -Body $body
# NB : PowerShell ne sait pas envoyer de fichier binaire via /api/chat aussi simplement.
# Sous Windows, le plus simple reste d'installer Git Bash (https://git-scm.com/download/win)
# et d'utiliser la version `curl` + `jq` (ou `grep`/`sed`) ci-dessus.

Ollama n'a besoin d'aucun de ces outils : c'est uniquement pour afficher la réponse joliment. Si vous ne voulez rien installer, lancez juste le curl simple et copiez le texte depuis la sortie JSON brute.

Si vous préférez quand même piloter Ollama depuis un script Python, c'est tout aussi simple avec la lib ollama officielle :

from ollama import chat

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

response = chat(
    model="gemma4:e4b",
    messages=[{
        "role": "user",
        "content": "Transcris cet audio en français.",
        "images": [audio_bytes],
    }],
)
print(response.message.content)

Sur le benchmark FLEURS (reconnaissance vocale multilingue), Gemma 4 e4b obtient un taux d'erreur mot de 0,08, comparable à Whisper-large pour la plupart des langues.

Les compromis à connaître

• Pas de streaming en direct : la transcription se fait sur le fichier audio complet, pas mot par mot en temps réel.
• Modèle 4B moins précis que Faster-Whisper large-v3 sur les cas difficiles : accents forts, bruit de fond, termes techniques rares.
• Pas de diarization intégrée : pour identifier les locuteurs, il faut toujours passer par WhisperX + pyannote (cf. paragraphe plus haut).

Et si ma machine n'est pas assez puissante ?

Il existe gemma4:cloud et gemma4:31b-cloud sur Ollama Cloud, mais ces variantes ne supportent pas l'audio en entrée (uniquement texte et image). Pour la transcription audio, l'option reste donc de faire tourner gemma4:e4b ou gemma4:e2b en local, ce qui est gratuit et illimité :

• 16 Go de RAM suffisent pour e4b en quantization Q4
• 8 Go de RAM suffisent pour e2b

Pour le français spécifiquement, Faster-Whisper large-v3 reste la valeur sûre en 2026. Moonshine est le bon choix si vous avez besoin de vrai streaming, c'est-à-dire d'un modèle qui sort la transcription au fil de l'eau (mot par mot ou phrase par phrase, en moins d'une seconde de latence), plutôt que d'attendre la fin d'un bloc de 5 secondes avant d'afficher quoi que ce soit. Concrètement, Moonshine brille dans trois cas :

• Sous-titrage en direct d'une visio ou d'une présentation : vous voulez que le texte s'affiche à l'écran pendant que quelqu'un parle, sans décalage perceptible.
• Dictée vocale interactive : vous dictez et le texte apparaît dans votre éditeur de texte en temps réel, comme dans un outil de dictée professionnelle.
• Accessibilité pour personne malentendante : la transcription doit suivre la parole à la vitesse de la conversation, sinon elle perd son utilité.

Dans ces trois cas, Moonshine consomme aussi très peu de RAM (245 M de paramètres, tient sur un laptop avec 8 Go), là où Faster-Whisper large-v3 demande 3 à 4 Go de RAM à lui seul.

Démarrage rapide : du micro au texte en 15 minutes

Le chemin le plus court vers un outil de transcription live fonctionnel est Faster-Whisper alimenté par le microphone système.

Prérequis

Il vous faut Python 3.9 ou plus récent installé sur votre machine. Si ce n'est pas encore le cas, récupérez-le depuis la page de téléchargement officielle : python.org/downloads. Sur GNU/Linux il est généralement déjà présent ; sur macOS et Windows suivez l'installateur.

Il vous faut aussi un dossier de travail dédié pour garder le projet isolé. Tout le tutoriel suppose que vous créez un dossier spécifique et que vous exécutez chaque commande depuis l'intérieur de celui-ci.

Créer un environnement Python isolé

Une fois dans votre dossier de travail, créez un environnement virtuel pour que les paquets installés n'aillent pas polluer le reste de votre système :

python3 -m venv venv
source venv/bin/activate

À partir de là, chaque pip install que vous lancez reste cantonné à ce dossier. Relancez source venv/bin/activate à chaque nouvelle ouverture de terminal quand vous voulez revenir au projet.

Installer les dépendances

# Faster-Whisper pour la transcription
pip install faster-whisper

# sounddevice + soundfile pour l'I/O micro
pip install sounddevice soundfile numpy

Script minimal de transcription live

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

SAMPLE_RATE = 16000
BLOCK_SECONDS = 5  # transcrire toutes les 5 secondes d'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... appuyez sur Ctrl+C pour arrêter.")
    sd.sleep(10**9)

Chaque bloc de 5 secondes est transcrit à la volée et affiché dans la console. vad_filter=True (détection d'activité vocale) ignore le silence pour ne pas nourrir le modèle avec du bruit quand personne ne parle, ce qui améliore la précision et divise le calcul par deux environ.

Pour cibler un microphone précis (un micro de conférence USB plutôt que le micro intégré), listez les devices avec python -m sounddevice et passez l'index :

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

Pour sauvegarder la transcription dans un fichier Markdown au lieu de juste l'afficher, écrivez dans un handle ouvert avec open("notes.md", "a"). Vous obtenez un log vivant de la réunion, prêt à être passé à un LLM local.

Si vous avez besoin de savoir qui a dit quoi (diarization), l'option de référence est WhisperX couplé à pyannote-audio — voir leur documentation pour le setup.

Résumer la transcription avec un LLM local

Une fois la transcription sur disque, un LLM local produit les notes de réunion. Ollama est l'interface la plus simple :

Le prompt standard, alimenté avec la transcription :

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)"

Pour les réunions en anglais, inversez la langue du prompt et choisissez un modèle tuné anglais.

Exigences matérielles (2026)

Le microphone lui-même compte plus qu'on ne le pense. Un micro USB cardioïde (Blue Yeti, Røde NT-USB Mini, Elgato Wave:1) donne un signal propre. Le micro intégré du laptop capte le ventilateur et le clavier et la précision de transcription baisse sensiblement.

Astuces spécifiques au microphone

Quelques leçons pratiques qui sautent aux yeux la première fois qu'on transcrit une réunion :

• Utilisez un casque ou un micro USB courte portée. Un micro à 50 cm du locuteur donne une bien meilleure précision de transcription que le micro intégré du laptop à 1 m sur le bureau.
• Activez la détection d'activité vocale. vad_filter=True dans Faster-Whisper saute les segments non parlés, donc le modèle ne voit que de vrais mots. Ça réduit aussi le calcul de moitié sur une réunion typique.
• Débruitez si besoin. RNNoise (pip install rnnoise) est un petit pré-filtre qui enlève le souffle et le bruit de ventilateur. Faites-le tourner sur le buffer audio avant de le passer à Whisper et la précision grimpe encore d'un cran sur les enregistrements bruités.
• Alignez la fréquence d'échantillonnage. Whisper attend du PCM mono 16 kHz. La plupart des micros sont par défaut à 44,1 ou 48 kHz ; rééchantillonnez en NumPy avant d'appeler transcribe.
• Fixez la langue explicitement. Passez language="fr" (ou "en") au lieu de laisser Whisper auto-détecter. L'auto-détection mange de la latence sur le premier chunk ; épingler la langue sauve un battement à chaque bloc.
• La taille de chunk est un bouton de latence. Des blocs de 3 secondes donnent du quasi temps réel. Des blocs de 5 secondes sont plus précis. Des blocs de 10 secondes maximisent la précision mais introduisent un délai notable. Commencez à 5 et ajustez.

Le verdict

La transcription audio live depuis un microphone est un des cas d'usage où l'IA locale est strictement meilleure que l'équivalent cloud. Faster-Whisper sur un seul GPU donne de la transcription temps réel en français et en anglais avec la même précision qu'une API commerciale, pyannote gère la partie « qui a dit quoi », et un petit LLM local transforme la transcription en notes de réunion structurées. Toute la stack est MIT ou Apache, tient sur un laptop de milieu de gamme, et garde l'audio — qui contient souvent le contenu le plus sensible de votre activité — sur du matériel que vous contrôlez.

Pour un test ponctuel, le démarrage rapide en 15 minutes ci-dessus suffit. Pour un vrai workflow qui tourne chaque semaine, installez le script live comme service systemd sur un mini-PC toujours allumé, pointez-le sur un micro USB sur votre bureau, et passez le log Markdown à un LLM local à la fin de chaque réunion.