Construire un assistant vocal entièrement hors ligne en 2026 : Whisper + LLM + Piper (guide étape par étape)

Faits rapides

• Couche STT : whisper.cpp (optimal pour Apple Silicon et embarqué), faster-whisper (optimal pour les pipelines Python GPU NVIDIA).
• Couche LLM : Ollama avec Llama 3.1 8B (recommandé), Phi-4 (plus léger) ou Mistral 7B.
• Couche TTS : Piper (plus rapide, CPU uniquement, temps réel sur Pi), Coqui TTS (meilleure qualité, GPU requis).
• Options de mot de déclenchement : OpenWakeWord (MIT, entièrement hors ligne), Porcupine (tier gratuit, 1 mot personnalisé).
• Matériel minimum : Raspberry Pi 5 avec 8 Go de RAM (~90 €) pour une latence de 5 à 8 secondes.
• Matériel recommandé : Mac Mini M5 24 Go (~600 €) ou PC de bureau avec RTX 3060 12 Go (~750 €) pour 1 à 2 secondes.
• Langues : Whisper supporte 99 langues. Piper supporte 20+ packs vocaux. Les performances LLM varient selon la langue.

Pourquoi construire un assistant vocal local ?

• Confidentialité : Aucun audio ne quitte votre réseau. Aucun historique de conversation sur des serveurs tiers. Essentiel pour les professionnels de santé, avocats, journalistes et toute personne traitant des données sensibles.
• Coût : Pas d'abonnement. Alexa+ coûte environ 4,99 €/mois. Google One coûte environ 1,99 à 9,99 €/mois. Un assistant local est un investissement matériel unique.
• Personnalisation : Choisissez votre mot de déclenchement, la personnalité, le prompt système et les fonctionnalités. Connectez des systèmes domotiques locaux, intégrez des API locales.
• Fonctionnement hors ligne : Fonctionne sans internet. Panne de courant (avec onduleur) + panne internet : votre assistant local continue de fonctionner.
• Ce que vous perdez : Recherche web, intégration domotique avec les clouds propriétaires, synchronisation d'agenda cloud, et les années d'optimisation RLHF qui rendent Alexa/Siri fluides pour les cas limites.

L'architecture en trois couches

• Couche 1 — STT : whisper.cpp ou faster-whisper. Convertit l'audio du microphone en texte. Fonctionne hors ligne, sans réseau.
• Couche 2 — LLM : Ollama avec Llama 3.1 8B, Phi-4 ou Mistral 7B. Reçoit le texte transcrit + l'historique + le prompt système et génère une réponse. Fonctionne hors ligne.
• Couche 3 — TTS : Piper ou Coqui TTS. Convertit le texte de réponse en audio et le diffuse via le haut-parleur. Fonctionne hors ligne.
• Orchestrateur : Un script Python qui relie les trois : capture audio → STT → transcript → LLM → réponse → TTS → audio diffusé.
• Mot de déclenchement optionnel : Un détecteur léger en permanence (OpenWakeWord, Porcupine) qui ne lance le pipeline complet que lorsque la phrase d'activation est détectée.

Configuration matérielle

Étape 1 : Configurer la reconnaissance vocale

• Installer whisper.cpp : git clone https://github.com/ggerganov/whisper.cpp && cd whisper.cpp && make -j4
• Télécharger le modèle : bash ./models/download-ggml-model.sh small (small = 3.4 % WER, bon équilibre vitesse/précision)
• Tester la transcription : ./main -m models/ggml-small.bin -f test.wav — doit produire une sortie texte précise.
• Activer Metal sur Mac : make -j4 WHISPER_COREML=1 puis bash models/generate-coreml-model.sh small
• Sélection du modèle : base pour Raspberry Pi (1 Go RAM, faible latence), small pour le meilleur compromis (2 Go RAM, 3.4 % WER), large-v3 pour la précision maximale (10 Go VRAM/RAM).
• Configurer la suppression du silence : Ajoutez --no-speech-threshold 0.6 --suppress-blank pour éviter de transcrire le silence en texte halluciné.
• Tester avec un enregistrement de 10 secondes : Vérifiez la transcription en conditions bruyantes et en parole faible.

Étape 2 : Configurer le LLM local

• Installer Ollama : Téléchargez depuis ollama.com. Disponible pour macOS, Linux et Windows. Installation en moins de 2 minutes.
• Télécharger le modèle : ollama pull llama3.1:8b (recommandé) ou ollama pull phi4 (plus léger, pour 16 Go de RAM).
• Tester : ollama run llama3.1:8b "What is the capital of France?" — vérifiez la précision et la rapidité.
• Prompt système pour la voix : « You are a helpful voice assistant. Keep responses concise — 1–3 sentences maximum. Never use bullet points, markdown, or formatting. Speak naturally as if in conversation. »
• Température : Réglez à 0.3–0.5 pour des réponses plus prévisibles et factuelles. Réduit les hallucinations.
• Nombre maximum de tokens : Limitez avec --num-predict 150 — les longues réponses prennent plus de temps en TTS et sonnent peu naturel à l'oral.

Étape 3 : Configurer la synthèse vocale

• Installer Piper : pip install piper-tts
• Télécharger une voix : piper --download-dir voices --update-voices --voice en_US-lessac-medium
• Tester : echo "Hello, how can I help you today?" | piper --model voices/en_US-lessac-medium.onnx --output-raw | aplay -r 22050 -f S16_LE -c 1
• Sortie audio : Piper génère du PCM brut ou du WAV. Redirigez vers aplay (Linux), afplay (Mac), ou utilisez sounddevice Python.
• Alternative (meilleure qualité) : Backend Coqui VITS — pip install TTS, tts --model_name tts_models/en/vctk/vits. Nécessite ~2 Go de VRAM, 2–3× plus lent.
• Sélection de la voix : Choisissez une voix de qualité moyenne — plus rapide et la différence est négligeable via un haut-parleur.

Étape 4 : Connecter le pipeline

#!/usr/bin/env python3
"""Minimal offline voice assistant: Whisper STT + Ollama LLM + Piper TTS."""

import subprocess
import tempfile
import sounddevice as sd
import soundfile as sf
import numpy as np
import requests
import json

SAMPLE_RATE = 16000
RECORD_SECONDS = 5
OLLAMA_URL = "http://localhost:11434/api/generate"
WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-small.bin"
PIPER_BIN = "piper"
PIPER_VOICE = "voices/en_US-lessac-medium.onnx"
SYSTEM_PROMPT = (
    "You are a helpful voice assistant. Keep responses to 1-3 sentences. "
    "Never use markdown, bullet points, or formatting. Speak naturally."
)

conversation_history = []

def record_audio(seconds: int = RECORD_SECONDS) -> np.ndarray:
    print("Listening...")
    audio = sd.rec(int(seconds * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype="int16")
    sd.wait()
    return audio

def transcribe(audio: np.ndarray) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, audio, SAMPLE_RATE)
        result = subprocess.run(
            [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", f.name, "--no-timestamps", "--no-prints"],
            capture_output=True, text=True
        )
    return result.stdout.strip()

def ask_llm(text: str) -> str:
    conversation_history.append({"role": "user", "content": text})
    response = requests.post(OLLAMA_URL, json={
        "model": "llama3.1:8b",
        "system": SYSTEM_PROMPT,
        "messages": conversation_history,
        "stream": False,
    })
    reply = response.json()["message"]["content"]
    conversation_history.append({"role": "assistant", "content": reply})
    return reply

def speak(text: str) -> None:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        subprocess.run(
            f'echo "{text}" | {PIPER_BIN} --model {PIPER_VOICE} --output_file {f.name}',
            shell=True, check=True
        )
        data, sr = sf.read(f.name)
        sd.play(data, sr)
        sd.wait()

def main():
    print("Voice assistant ready. Press Ctrl+C to stop.")
    while True:
        audio = record_audio()
        transcript = transcribe(audio)
        if not transcript or len(transcript) < 3:
            continue
        print(f"You: {transcript}")
        response = ask_llm(transcript)
        print(f"Assistant: {response}")
        speak(response)

if __name__ == "__main__":
    main()

Étape 5 : Détection du mot de déclenchement

• OpenWakeWord (licence MIT) : Entièrement open-source, tourne sur CPU, supporte des mots personnalisés via fine-tuning. Installation : pip install openwakeword. Fonctionne sur Raspberry Pi.
• Porcupine (Picovoice) : Propriétaire avec tier gratuit pour usage personnel. Mots préconfigurés : « Alexa », « Hey Siri », « Ok Google », « Hey Jarvis ». Très bonne précision. Installation : pip install pvporcupine.
• Schéma d'intégration : Faites tourner le détecteur en boucle. À la détection, jouez un son « ding », déclenchez le pipeline pour une requête, puis revenez à l'écoute.
• Fonctionnement en continu : La détection utilise ~2–5 % de CPU sur Raspberry Pi 5 — négligeable. L'assistant peut tourner 24h/24.
• Mots personnalisés (OpenWakeWord) : Générez 500 exemples positifs et 500 négatifs via TTS, puis affinez OpenWakeWord en moins de 30 minutes sur CPU.

Optimisation de la latence

• Optimisation STT (~0,2–0,5 s) : Utilisez Whisper small plutôt que large-v3. Utilisez la VAD pour couper le silence avant de passer l'audio à Whisper.
• Optimisation LLM (~0,5–1,5 s premier token) : Préchargez le modèle au démarrage (Ollama le fait automatiquement). Utilisez Q4_K_M. Définissez --num-predict 100–150.
• Streaming LLM → TTS : Streamez la sortie du LLM token par token. Lancez le TTS à chaque phrase complète. Réduit la latence perçue de 0,3 à 0,7 s.
• Optimisation TTS (~0,1–0,3 s) : Piper génère le premier audio en 50 ms. Pré-initialisez Piper au démarrage. Utilisez --output-raw pour le streaming.
• Maintenir les modèles en mémoire : Ollama maintient les modèles chauds en VRAM automatiquement. Évitez de recharger les modèles entre les requêtes.
• Objectifs par configuration : Pi 5 : 5–8 s. Mini PC CPU : 3–5 s. GPU de bureau : 1–2 s. Mac M5 : 1–1,5 s.

Confidentialité et sécurité

• Vérifiez avec Wireshark : Lancez Wireshark pendant une conversation. Vous ne devriez voir aucun paquet provenant du processus assistant. Tout trafic inattendu indique une mauvaise configuration.
• Aucun audio stocké : Ni whisper.cpp ni faster-whisper n'écrivent de fichiers audio par défaut. L'orchestrateur écrit un fichier WAV temporaire supprimé après la transcription.
• Aucun historique stocké : L'historique dans le script d'exemple est en mémoire uniquement. Pour un historique persistant, implémentez un stockage local avec chiffrement au repos.
• Conformité RGPD et CNIL : Comme tout le traitement est local et qu'aucune donnée ne quitte votre réseau, aucun contrat de sous-traitance n'est requis. La CNIL recommande le traitement local des données vocales sensibles (médicales, juridiques, financières) pour éviter tout transfert vers des prestataires tiers.
• Isolation réseau : Ajoutez une règle de pare-feu bloquant le trafic sortant du processus assistant pour une confidentialité maximale. Ollama et whisper.cpp fonctionneront normalement après le téléchargement des modèles.

FAQ

Sources

• whisper.cpp sur GitHub — Code source, instructions de build, documentation du mode stream.
• Ollama sur ollama.com — Installation, bibliothèque de modèles, référence API.
• Piper TTS sur GitHub — Code source, téléchargements de packs vocaux, guide Raspberry Pi.
• OpenWakeWord sur GitHub — Code source, guide d'entraînement de mots personnalisés.
• Porcupine par Picovoice — SDK de mot de déclenchement, conditions du tier gratuit, documentation Python.
• Picovoice Console — Créez une clé API gratuite pour Porcupine (usage personnel).

Lectures connexes

• Reconnaissance vocale locale 2026 : Whisper.cpp vs faster-whisper — Analyse approfondie de la couche STT de ce pipeline.
• TTS local et clonage vocal 2026 : Piper vs Coqui vs XTTS v2 — Analyse approfondie de la couche TTS et des options de clonage vocal.
• Pipeline IA multimodale local 2026 — Étendre ce pipeline vocal avec le support de modèles de vision.
• Installer Ollama — Installation d'Ollama et gestion des modèles.
• Guide matériel LLM local 2026 — Sélection du matériel pour le pipeline complet.
• Construire un assistant vocal local sur votre téléphone — La version mobile de ce guide (iPhone et Android).