Das Mikrofon mit PyAudio erfassen
Auf dieser Seite
Kurs aktualisiert am 3. November 2026 für Voxtral 3, basierend auf Mistrals Leitfaden Migrate from Voxtral 2: Die Voxtral 2-Modelle (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), die am 31. Oktober 2026 veraltet und am 30. April 2027 zurückgezogen wurden, werden in den Beispielen durchvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3undvoxtral-mini-tts-3-0ersetzt. Wesentliche Änderungen: Zeitstempel sind segmentbezogen (die Rückgabe vonwordführt zu einem 400-Fehler), Echtzeit-Diarisierung wird unterstützt, Echtzeit-Sitzungseinstellungen werden nach dem ersten Audio-Chunk gesperrt, undcontext_bias-Eingaben sind flexibel (Phrasen mit Leerzeichen). Quellen: Migrate from Voxtral 2 · Speech to Text.
Vom Datei- zum Mikrofon-Eingang
Die vorherige Lektion hat eine Architektur etabliert, bei der die Audioquelle ein einfacher, austauschbarer asynchroner Generator ist. Sie werden dies sofort nutzen: Indem Sie den Datei-Lese-Generator durch einen ersetzen, der von Ihrer Soundkarte liest, beginnt Ihr Programm, Ihre Stimme live zu transkribieren, ohne eine einzige Zeile des übrigen Codes zu ändern.
Das Werkzeug für diese Lektion ist PyAudio, die Standard-Bibliothek in Python für den Zugriff auf Audio-Geräte. Sie stützt sich auf PortAudio, eine native Schicht, die je nach System möglicherweise separat installiert werden muss.
Installation von PyAudio
# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio
# macOS
brew install portaudio
pip install pyaudio
# Windows
pip install pyaudio
Der Mikrofon-Generator
Der Kern dieser Lektion fasst sich in etwa dreißig Zeilen zusammen. Die Funktion öffnet einen Eingangsstrom auf dem Standardgerät, liest in einer Endlosschleife Blöcke fester Größe und gibt jeden an den Transkriptions-Engine weiter. Der finally-Block ist nicht dekorativ: Er garantiert, dass der Strom gestoppt, geschlossen wird und PyAudio die Hardware freigibt, selbst wenn das Programm abrupt unterbrochen wird. Ohne ihn kann das Mikrofon weiterhin gesperrt bleiben und andere Anwendungen blockieren.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Erfasse das Mikrofon und gib PCM-Blöcke aus.
Args:
sample_rate: Abtastrate (16000 Hz für Voxtral)
chunk_duration_ms: Dauer jedes Chunks in Millisekunden
Yields:
bytes: 16-Bit Mono PCM Audio-Blöcke
"""
p = pyaudio.PyAudio()
# Anzahl der Samples pro Chunk
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Öffne den Mikrofon-Strom
stream = p.open(
format=pyaudio.paInt16, # 16-Bit PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Erfassungsmodus
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofon aktiv — sprechen...")
while True:
# Lies das Chunk nicht-blockierend
data = await loop.run_in_executor(
None,
stream.read,
chunk_samples,
False # exception_on_overflow
)
yield data
finally:
stream.stop_stream()
stream.close()
p.terminate()
print("Mikrofon geschlossen")
Jeder Parameter hat einen spezifischen Grund. sample_rate=16000 spiegelt eine Modellanforderung wider, keine Präferenz: Voxtral erwartet 16 kHz, ändern Sie diesen Wert daher nicht. pyaudio.paInt16 entspricht dem vorzeichenbehafteten 16-Bit PCM-Format, was exakt dem pcm_s16le entspricht, das auf der API-Seite deklariert ist, und channels=1 erzwingt Mono, was ebenfalls erforderlich ist. Das bleibt chunk_duration_ms=480, die einzige wirklich diskutierbare Einstellung: Jedes Chunk repräsentiert 480 Millisekunden Audio, ein guter Kompromiss zwischen Reaktionsfähigkeit und Netzwerkeffizienz. Ein kürzeres Chunk, sagen wir 100 ms, verbessert die Reaktionsfähigkeit, vervielfacht aber die Netzwerkanfragen; ein längeres Chunk spart Bandbreite, kostet aber Latenz, bevor das Modell das Audio sieht.
Der Aufruf loop.run_in_executor verdient ebenfalls eine Erklärung. stream.read ist eine blockierende Funktion: Sie hält den Thread, bis die angeforderte Anzahl an Samples verfügbar ist. Wenn man sie direkt in einer Coroutine ausführt, würde der gesamte asyncio-Loop eingefroren, einschließlich der Empfangsereignisse von Transkriptionen. Durch das Auslagern an einen Executor machen Sie das Lesen für den restlichen asynchronen Programmablauf kompatibel.
Die Berechnung der Blockgröße folgt mechanisch aus den beiden Einstellungen, für sample_rate=16000 und chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 Samples
byte_size = 7680 × 2 Bytes = 15360 Bytes pro Chunk
Komplettes Programm: Vom Mikrofon zur Transkription
Der folgende Skript kombiniert Erfassung und Transkription zu einem sofort einsatzbereiten Diktier-Tool. Das neue Element im Vergleich zum vorherigen Generator ist die saubere Beendigungsbearbeitung: Ein Signal-Handler fängt Ctrl+C ab, setzt die running-Flagge auf False, wodurch der Erfassungs-Loop beendet wird, der Strom geschlossen wird und das Programm den gesammelten Text speichern kann. Ohne diesen Mechanismus würde eine Tastaturunterbrechung den Prozess töten, bevor gespeichert wird, und Sie würden das Diktat verlieren.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Flagge für saubere Beendigung
running = True
def signal_handler(sig, frame):
global running
print("\n\nBeenden...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Erfasse das Mikrofon bis zur Unterbrechung (Ctrl+C)."""
p = pyaudio.PyAudio()
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
while running:
data = await loop.run_in_executor(
None, stream.read, chunk_samples, False
)
yield data
finally:
stream.stop_stream()
stream.close()
p.terminate()
async def main():
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
print("=" * 50)
print("LIVE-TRANSKRIPTION")
print("Sprechen Sie in das Mikrofon (Ctrl+C zum Stoppen)")
print("=" * 50)
print()
full_text = []
async for event in client.audio.realtime.transcribe_stream(
audio_stream=iter_microphone(),
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
):
if isinstance(event, TranscriptionStreamTextDelta):
print(event.text, end="", flush=True)
full_text.append(event.text)
elif isinstance(event, TranscriptionStreamDone):
break
# Speichern
final_text = "".join(full_text)
if final_text.strip():
with open("dictee.txt", "w", encoding="utf-8") as f:
f.write(final_text)
print(f"\n\nTranskription gespeichert in dictee.txt")
print(f"Länge: {len(final_text)} Zeichen")
else:
print("\n\nKein Text transkribiert.")
asyncio.run(main())
Führen Sie es aus, sprechen Sie, stoppen Sie mit Ctrl+C: Der Text erscheint, während Sie sprechen, und landet dann in dictee.txt.
python dictee_vocale.py
# Sprechen Sie in Ihr Mikrofon
# Text erscheint in Echtzeit
# Ctrl+C zum Stoppen
Probieren Sie es mit etwa dreißig Sekunden kontinuierlichem Französisch aus, variieren Sie das Tempo und vergleichen Sie, was Sie gesagt haben, mit dem, was die Datei enthält. Das ist der beste Weg, um Ihre Erwartungen zu kalibrieren, bevor Sie in der nächsten Lektion die Latenz anpassen.
Das richtige Gerät auswählen
Auf einem Gerät mit integriertem Mikrofon, einem USB-Headset und einer Webcam ist das Standardgerät nicht immer das, das man denkt, und eine leere Transkription kommt meist auf diese Detail zurück. Listen Sie zunächst verfügbare Eingänge mit ihrem Index auf:
def list_microphones():
"""Liste alle verfügbaren Audio-Eingabegeräte auf."""
p = pyaudio.PyAudio()
print("Verfügbare Eingabegeräte:")
for i in range(p.get_device_count()):
info = p.get_device_info_by_index(i)
if info["maxInputChannels"] > 0:
print(f" [{i}] {info['name']} "
f"(Kanäle: {info['maxInputChannels']}, "
f"Rate: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Enforzen Sie dann einfach den gewählten Index beim Öffnen des Stroms über den Parameter input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Geräteindex
frames_per_buffer=chunk_samples
)
Kernaussagen
- PyAudio erfasst das Mikrofon in 16-Bit Mono PCM bei 16 kHz, genau das, was Voxtral erwartet
- Der
iter_microphone-Generator gibt standardmäßig 480 ms-Blöcke aus loop.run_in_executormacht das Mikrofon-Lesen in asyncio nicht-blockierend- Ctrl+C stoppt die Erfassung sauber über einen Signal-Handler
- Listen Sie Geräte mit
get_device_count()auf, um das richtige Mikrofon auszuwählen