Mittelstufe 18 minAudio

Whisper + Ollama lokal: Transkription zu 100 % offline ligne

Eine einstündige Besprechung transkribieren und anschließend ein strukturiertes Protokoll daraus erstellen: Genau das verkaufen Otter, Fireflies oder Tactiq – gegen die Übermittlung Ihrer Audiodatei an einen Drittanbieter. Whisper (von OpenAI, aber Open Source und offline ausführbar) macht gekoppelt mit einem LLM Ollama dasselbe auf Ihrem Rechner, ohne Abonnement und ohne Datenleck. Dieser Leitfaden setzt die Pipeline whisper.cpp → Ollama vollständig um: Installation, Modellauswahl, Bash-Skript, Python-Skript und ein konkreter Anwendungsfall für die lokale Transkription einer 1-stündigen Besprechung.

Von Mohamed Meguedmi·Aktualisierung 2026-08-27·Unter Windows, macOS und Linux getestet

#Warum eine Pipeline mit Whisper + Ollama für lokale Transkription?

Eine Besprechungsaufzeichnung enthält Kundennamen, Zahlen, strategische Entscheidungen und manchmal auch Personaldaten. SaaS-Transkriptionsdienste speichern diese Audiodateien auf ihren Servern und verwenden sie (je nach Nutzungsbedingungen), um ihre eigenen Modelle zu trainieren. Für ein Team, das Vertraulichkeit ernst nimmt, ist das nicht verhandelbar.

Whisper von OpenAI lässt sich frei herunterladen und läuft offline. whisper.cpp (die C++-Portierung von Georgi Gerganov) führt es effizient auf CPU und GPU aus, ohne dass Python oder CUDA zwingend erforderlich sind. Ollama stellt seinerseits ein lokales LLM unter http://localhost:11434 bereit. Die beiden Bausteine greifen ineinander: Audio → Text (Whisper) → strukturierte Zusammenfassung (Ollama). Alles bleibt auf Ihrem Datenträger.

i
Die Aufteilung
Whisper ≠ LLM. Whisper ist ein Spracherkennungsmodell (ASR): Es wandelt Audio in Rohtext um. Das Zusammenfassen, die Formatierung und das Extrahieren von Entscheidungen übernimmt anschließend ein LLM. Diese beiden Modelle sind grundverschieden und können einander nicht ersetzen.

#Voraussetzungen

Das komplette Kit, um deinen eigenen KI-Assistenten zu erstellen.

Profitiere von unserer Erfahrung und einem geführten Lernpfad, um deinen lokalen Assistenten zu erstellen und deine KI im Alltag zu nutzen.

  • Lebenslanger Online-Zugang
  • PDF + Dateien
  • Erstattung binnen 30 Tagen
macOS, Linux oder Windows (WSL2)
whisper.cpp lässt sich überall kompilieren. Unter reinem Windows verwenden Sie WSL2 – die native Kompilierung funktioniert, erfordert aber mehr Bastelarbeit.
Ollama installiert und betriebsbereit
Der Befehl ollama run qwen3.5:9b muss eine Antwort liefern. Andernfalls gehen Sie noch einmal den Installationsleitfaden für Ihr Betriebssystem durch.
C++-Compiler und CMake
build-essential cmake unter Debian/Ubuntu, Xcode Command Line Tools unter macOS.
ffmpeg
Zum Umwandeln Ihrer .m4a/.mp3/.mp4-Dateien in WAV mit 16 kHz, das einzige Eingabeformat, das whisper.cpp akzeptiert.
Mindestens 8 GB RAM
16 GB sind komfortabel. Das Modell large-v3 belegt etwa 3 GB RAM/VRAM. Ein zusätzliches kleines LLM wie Qwen 3.5 4B benötigt etwa 3 GB.
Optionale GPU
Eine RTX 3060 mit 12 GB transkribiert 1 Stunde Audio in ca. 4 Minuten mit large-v3. Auf Apple Silicon ist Metal automatisch aktiviert und genauso schnell.

#1. whisper.cpp installieren

Kein offizielles Paket: Man klont das Repository und kompiliert es. Das dauert 2 Minuten und ergibt eine portable Binärdatei, die Sie beliebig verschieben können.

Klonen + CPU-Build
git clone https://github.com/ggerganov/whisper.cpp.git
cd whisper.cpp
cmake -B build
cmake --build build --config Release -j

Die Hauptbinärdatei liegt unter build/bin/whisper-cli (vor der CMake-Umstrukturierung hieß sie main). Diese Datei rufen Sie zum Transkribieren auf.

→
GPU-Beschleunigung
Für CUDA (NVIDIA) fügen Sie dem Befehl cmake -B build die Option -DGGML_CUDA=1 hinzu. Auf Apple Silicon ist Metal standardmäßig aktiviert – es muss nichts konfiguriert werden. Für AMD (ROCm): -DGGML_HIPBLAS=1. Das ausführbare Programm erkennt anschließend beim Start die GPU.
CUDA-Variante
cmake -B build -DGGML_CUDA=1
cmake --build build --config Release -j

Installieren Sie ffmpeg separat, falls dies noch nicht geschehen ist:

ffmpeg
# Debian / Ubuntu / WSL2
sudo apt install ffmpeg

# macOS
brew install ffmpeg

#2. Das richtige Whisper-Modell wählen (tiny → large-v3)

Whisper gibt es in fünf Größen, jeweils in zwei Varianten: mehrsprachig (Standard) und nur für Englisch (Suffix .en). Für Französisch bleiben Sie bei der mehrsprachigen Variante. Die folgende Tabelle fasst die wesentlichen Unterschiede zusammen.

tiny (75 MB)
Schnell, aber bei Französisch mittelmäßig. Nur für schnelle Tests oder Raspberry Pi geeignet. WER (Fehlerquote) bei spontan gesprochenem Französisch: etwa 30 %.
Basis (142 MB)
Akzeptabel bei klar verständlichem Englisch, schwach bei französischen Sprachaufnahmen mit Störgeräuschen. Eine gute Option, wenn Ihnen nur sehr wenige Ressourcen zur Verfügung stehen.
small (466 MB)
Die erste wirklich brauchbare Stufe. WER ~10–12 % bei klar gesprochenem Französisch. Transkribiert 1 Stunde Audio in etwa 3 Minuten auf einer GPU der unteren Leistungsklasse.
medium (1,5 GB)
Sehr guter Kompromiss zwischen Qualität und Geschwindigkeit für Französisch in Besprechungen. WER ~7–8 %. Erkennt Satzzeichen gut.
large-v3 (3,1 GB)
Stand der Technik. Bei klar gesprochenem Französisch nahezu perfekt, robust gegenüber Akzenten und Hintergrundgeräuschen. Zu bevorzugen, sobald mehr als 6 GB RAM/VRAM frei sind.

Für die Transkription einer Besprechung auf Französisch lautet die praktische Empfehlung: medium als Standard, large-v3, wenn Sie eine ausreichend leistungsfähige GPU haben. small ist eine gute Ausweichlösung auf einem Laptop ohne dedizierte GPU.

Ein Modell herunterladen
# Depuis le dossier whisper.cpp
./models/download-ggml-model.sh medium
# ou
./models/download-ggml-model.sh large-v3

Die Modelle werden im Verzeichnis models/ im Format ggml bereitgestellt (dem Äquivalent zu gguf für LLMs). Sie können mehrere Größen herunterladen und je nach Bedarf zwischen ihnen wechseln.

i
Quantisierte Versionen
Wenn der VRAM knapp ist, unterstützt das Skript quantisierte Varianten: large-v3-q5_0 (≈1,1 GB) oder medium-q5_0 (≈540 MB). Der Qualitätsverlust ist bei französischsprachigen Aufnahmen gering, die Speichereinsparung ist real. Mit eigenen Audioaufnahmen testen.

#3. Eine Audiodatei transkribieren

whisper.cpp liest nur WAV-Dateien mit 16 kHz in Mono. Wir verwenden ffmpeg, um das Audio vorzubereiten, und anschließend whisper-cli, um es zu transkribieren.

Konvertierung in WAV mit 16 kHz
ffmpeg -i reunion.m4a -ar 16000 -ac 1 -c:a pcm_s16le reunion.wav
-ar 16000
Resampling auf 16 kHz (die Abtastrate, mit der Whisper trainiert wurde).
-ac 1
Erzwingt Mono. Whisper ignoriert Stereo ohnehin.
-c:a pcm_s16le
16-Bit-PCM in Little-Endian, das erwartete unkomprimierte WAV-Format.
Transkription
./build/bin/whisper-cli \
  -m models/ggml-medium.bin \
  -f reunion.wav \
  -l fr \
  -otxt \
  -of reunion

Das Ergebnis wird mit Segmenten samt Zeitstempeln in reunion.txt gespeichert. Einige nützliche Flags, die Sie kennen sollten:

-l fr
Erzwingt Französisch. Ohne dieses Flag erkennt Whisper die Sprache automatisch – liegt bei kurzen Sätzen aber manchmal falsch.
-otxt / -osrt / -ovtt / -ojson
Ausgabeformat: Klartext, SRT- oder VTT-Untertitel oder strukturiertes JSON mit Zeitstempeln. Sie können sie kombinieren.
-of <Präfix>
Präfix der Ausgabedateien (ohne Dateiendung).
-t 8
Anzahl der CPU-Threads. Standardmäßig verwendet whisper.cpp 4 – erhöhen Sie die Anzahl bei einer modernen CPU auf 8 oder 16.
--print-progress
Zeigt einen Fortschrittsbalken an. Praktisch für lange Dateien.
→
JSON-Format für die Pipeline
Für die anschließende Verarbeitung mit einem LLM verwenden Sie vorzugsweise -ojson: So erhalten Sie die Segmente mit ihren Start- und Endzeitstempeln. Damit können Sie in der abschließenden Zusammenfassung einen genauen Zeitstempel angeben („Entscheidung bei 23:14 getroffen“).

#4. Die Transkription mit Ollama zusammenfassen

Sobald die Rohtranskription vorliegt, wird sie über Ollamas lokale HTTP-API an Ollama gesendet. Der Endpunkt /api/chat ist der direkteste Weg für eine einmalige Anfrage.

Voraussetzungen für Ollama
ollama pull qwen3.5:9b
# Ou pour un résumé plus fin d'une longue réunion :
ollama pull mistral-small

Für eine 1h dauernde Besprechung umfasst die Transkription problemlos 10 000 bis 15 000 Tokens. Qwen 3.5 9B unterstützt nativ einen Kontext von 256k, das ist mehr als ausreichend. Für eine noch sorgfältigere Zusammenfassung passt Mistral Small 24B (hervorragend auf Französisch) unter 16 GB VRAM.

Schnelltest per curl
curl -s http://localhost:11434/api/chat -d '{
  "model": "qwen3.5:9b",
  "stream": false,
  "options": {"temperature": 0.2, "num_ctx": 16384},
  "messages": [
    {"role": "system", "content": "Tu résumes une réunion de travail en français."},
    {"role": "user", "content": "<COLLE ICI LE CONTENU DE reunion.txt>"}
  ]
}' | jq -r '.message.content'
!
num_ctx, nicht standardmäßig
Ollama lädt seine Modelle standardmäßig mit einem Kontext von 2048 Tokens, was Ihre Transkription unbemerkt abschneiden würde. Geben Sie bei jedem Aufruf explizit num_ctx (8192, 16384, 32768…) in options an — oder legen Sie den Wert über ein Modelfile fest.

#5. Vollständige Pipeline: Beispiel für ein Sitzungsprotokoll (1 h)

Wir fassen alles in einem Python-Skript zusammen, das eine Audiodatei als Eingabe erhält und einen Bericht im Markdown-Format ausgibt. Das ist der Kern einer wiederverwendbaren Pipeline für lokale Transkription mit Whisper und Ollama.

Python-Abhängigkeiten
pip install requests
pipeline_reunion.py
#!/usr/bin/env python3
"""Audio -> transcription Whisper -> compte-rendu via Ollama."""
import subprocess, sys, requests, pathlib, json

WHISPER_BIN = "./build/bin/whisper-cli"
WHISPER_MODEL = "models/ggml-medium.bin"
OLLAMA_URL = "http://localhost:11434/api/chat"
LLM_MODEL = "qwen3.5:9b"

SYSTEM_CR = """Tu es un assistant qui produit des comptes-rendus de
réunion en français à partir d'une transcription brute.

FORMAT DE SORTIE (Markdown) :
# Compte-rendu
## Participants identifiables
## Sujets abordés (1 paragraphe par sujet)
## Décisions prises
## Actions à mener (avec porteur si mentionné)
## Points en suspens

RÈGLES :
- N'invente AUCUN nom, AUCUNE décision, AUCUNE action.
- Si une info manque, écris \"Non précisé\".
- Sois concis : un compte-rendu se lit en 2 minutes.
"""

def to_wav(src: pathlib.Path) -> pathlib.Path:
    dst = src.with_suffix(".wav")
    subprocess.run([
        "ffmpeg", "-y", "-i", str(src),
        "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le",
        str(dst),
    ], check=True)
    return dst

def transcribe(wav: pathlib.Path) -> str:
    prefix = wav.with_suffix("")
    subprocess.run([
        WHISPER_BIN, "-m", WHISPER_MODEL, "-f", str(wav),
        "-l", "fr", "-otxt", "-of", str(prefix),
        "--print-progress",
    ], check=True)
    return prefix.with_suffix(".txt").read_text(encoding="utf-8")

def summarize(transcription: str) -> str:
    r = requests.post(OLLAMA_URL, json={
        "model": LLM_MODEL,
        "stream": False,
        "options": {"temperature": 0.2, "num_ctx": 16384},
        "messages": [
            {"role": "system", "content": SYSTEM_CR},
            {"role": "user",   "content": transcription},
        ],
    }, timeout=600)
    r.raise_for_status()
    return r.json()["message"]["content"]

if __name__ == "__main__":
    src = pathlib.Path(sys.argv[1])
    wav = to_wav(src)
    print(f"[1/3] Audio converti -> {wav}")
    texte = transcribe(wav)
    print(f"[2/3] Transcription : {len(texte)} caractères")
    cr = summarize(texte)
    out = src.with_name(src.stem + "_compte-rendu.md")
    out.write_text(cr, encoding="utf-8")
    print(f"[3/3] Compte-rendu : {out}")
Start
python pipeline_reunion.py reunion.m4a

Bei einer 1-Stunden-Sitzung mit einer RTX 3060 12 GB und dem mittleren Modell: ca. 3 Minuten für die Transkription, ca. 30 Sekunden für die Zusammenfassung Qwen 3.5 9B. Gesamtzeit: weniger als 4 Minuten, keine Netzwerkabfrage. Auf einem MacBook M2 16 GB mit CPU und Metal: ca. 6 Minuten Gesamtzeit.

→
Sehr lange Besprechungen
Bei mehr als 90 Minuten oder mehr als 30.000 Tokens Transkription teilen Sie den Text in Blöcke von 10.000 Tokens auf, fassen Sie jeden Block zusammen und bitten Sie anschließend das LLM, die Zusammenfassungen zusammenzuführen. Das ist das klassische Map-Reduce-Muster. Andernfalls bricht die Qualität der Zusammenfassung ein, selbst wenn num_ctx diese Länge zulässt.

#Tipps und Fehlerbehebung

Transkription, die in stillen Passagen halluziniert
Whisper erfindet in langen Pausen manchmal Sätze („Untertitel von …“, „Danke fürs Zuschauen“). Aktivieren Sie VAD: --vad --vad-model models/ggml-silero-v5.1.2.bin (über dasselbe Skript herunterzuladen).
Verfälschte Eigennamen
Whisper kennt die Namen Ihrer Kollegen nicht. Geben Sie sie über --prompt "Marie, Julien, Samir, ACME Corp, ProjetX" im initialen Prompt an. Dann werden sie korrekt geschrieben.
Komprimiertes Audio (Zoom, Teams)
Zoom-Aufzeichnungen im MP4-Format enthalten häufig eine Mono-Audiospur von schlechter Qualität. Bevorzugen Sie den Zoom-Export „Nur Audio“ (M4A), oder zeichnen Sie parallel mit OBS auf, wenn die Qualität Vorrang hat.
Fehler ggml_metal_init auf dem Mac
Sie haben ohne Metal kompiliert oder whisper.cpp findet die Ressourcen nicht. Kompilieren Sie von Grund auf neu: rm -rf build && cmake -B build && cmake --build build --config Release -j.
Ollama-Timeout bei großem Kontext
Der HTTP-Client bricht ab, bevor die Verarbeitung abgeschlossen ist. Erhöhen Sie bei requests den Timeout auf timeout=600 (10 Minuten). Auf der Serverseite hält OLLAMA_KEEP_ALIVE=30m das Modell geladen.
Abgeschnittene Transkription
Wenn die Zusammenfassung den Eindruck erweckt, dass das Audio nur bis zu einem bestimmten Punkt berücksichtigt wurde, ist num_ctx zu niedrig. Prüfen Sie die Anzahl der Tokens (wc -w für die .txt-Datei × 1.3 ≈ Tokens) und setzen Sie num_ctx auf das Doppelte dieser Anzahl.
Diarisierung (wer spricht)
whisper.cpp führt keine Sprecherdiarisierung durch. Um die Sprecher zu unterscheiden, fügen Sie pyannote.audio vor der Transkription in die Pipeline ein und annotieren Sie anschließend jedes Segment. Das ist eine zusätzliche Ebene, die hier nicht behandelt wird.
i
Konkrete Hardwarekosten
Für den täglichen Gebrauch – 2 bis 3 transkribierte Meetings pro Tag – reicht ein Mac mini M4 16 GB (~700 €) oder ein Mini-PC mit RTX 3060 12 GB (~600 € gebraucht) völlig aus. Es ist eine einmalige Investition im Vergleich zu ~15 €/Monat/Nutzer bei Transkriptions-SaaS, die sich für ein Team von 5 Personen in weniger als einem Jahr amortisiert.

#Weiterführende Informationen

Ihre Pipeline transkribiert und fasst lokal zusammen. Je nach Bedarf bieten sich drei sinnvolle nächste Schritte an:

Medizinischer Bericht mit faster-whisper
Der Leitfaden zur Transkription medizinischer Konsultationen verwendet faster-whisper (optimierte Python-Portierung) mit Schwerpunkt auf der medizinischen Schweigepflicht, der Diarisierung mit pyannote und der DSGVO-Konformität im Gesundheitsbereich. Eine interessante Variante desselben Musters.
Das richtige LLM für Zusammenfassungen auswählen
Die Zusammenfassung ist das Glied in der Kette, bei dem die Qualität am stärksten schwankt. Der Leitfaden zur Auswahl der Quantisierung vergleicht Q4_K_M, Q5_K_M und Q8_0 — bei langen, nuancenreichen Texten ist der Unterschied spürbar.
Die Pipeline mit n8n automatisieren
Der Leitfaden zur Automatisierung mit n8n + Ollama zeigt, wie Sie ohne Code einen Workflow erstellen, der die Verarbeitungskette auslöst, sobald eine Audiodatei eingeht (überwachter Ordner, E-Mail, Slack).
Hat Ihnen dieser Guide geholfen?

Haben Sie Feedback, einen Fehler entdeckt oder möchten Sie etwas präzisieren? Geben Sie uns Bescheid – so wird der Guide für alle besser.