Voicebox — Le Studio Vocal IA Open-Source pour la Synthèse Vocale et le Clonage de Voix Auto-Hébergés

Qu'est-ce que Voicebox ?

Voicebox est un studio vocal IA open-source, local-first qui vous offre une pile complète d'entrée/sortie vocale — synthèse vocale, clonage de voix, reconnaissance vocale, dictée et sortie vocale pour agents IA — le tout fonctionnant sur votre propre machine. Considérez-le comme une alternative auto-hébergée à ElevenLabs (TTS) et WisprFlow (dictée) combinés, avec une confidentialité totale puisque les modèles, les données vocales et les enregistrements ne quittent jamais votre matériel.

GitHub: github.com/jamiepine/voicebox
Stars: ⭐ 32 000+
Licence: MIT
Langage: TypeScript (frontend) + Python FastAPI (backend) + Rust (coque Tauri)
Site web: voicebox.sh

Pourquoi c'est important : Le clonage vocal et la synthèse vocale de haute qualité étaient verrouillés derrière des API cloud avec une facturation à l'utilisation. Voicebox apporte 7 moteurs TTS (Qwen3-TTS, Chatterbox, Kokoro, LuxTTS, TADA), le clonage vocal zero-shot à partir de quelques secondes d'audio, la dictée basée sur Whisper et la sortie vocale pour agents IA via MCP sur votre propre serveur ou bureau. Aucune donnée ne quitte votre machine, pas de facturation par caractère.

Fonctionnalités Clés

Architecture

Voicebox suit une architecture en couches avec une coque de bureau Tauri encapsulant un backend Python FastAPI et un frontend React. Le backend orchestre plusieurs moteurs TTS, Whisper STT, un LLM Qwen3 intégré et des pipelines d'effets audio, le tout exposé via une API REST et un serveur MCP pour l'intégration avec les agents IA.

Voici comment les composants interagissent :

1. L'utilisateur interagit via le frontend React (web ou bureau Tauri) ou directement via l'API REST
2. Le Backend FastAPI achemine les requêtes vers le moteur approprié : TTS, STT (Whisper) ou LLM (Qwen3)
3. 7 moteurs TTS gèrent la génération texte-parole avec différentes forces (vitesse, qualité, couverture linguistique)
4. Whisper STT transcrit l'audio provenant de la dictée ou des fichiers téléchargés
5. Qwen3 LLM alimente les personnalités vocales (composition, réécriture) et le raffinement de la dictée
6. Pipeline d'Effets Audio (Pedalboard de Spotify) applique le post-traitement : changement de hauteur, réverbération, délai, etc.
7. Base de données SQLite conserve les profils vocaux, générations, captures et paramètres
8. Serveur MCP (monté sur /mcp) expose speak, transcribe, list_captures et list_profiles aux agents IA
9. Backends d'inférence se sélectionnent automatiquement : MLX (Apple Silicon), CUDA (NVIDIA), ROCm (AMD) ou CPU en fallback

L'architecture est conçue pour être complètement utilisable hors ligne — tous les modèles se téléchargent lors de la première utilisation et fonctionnent localement par la suite.

Prérequis

• Un serveur avec Docker et Docker Compose installés (recommandé pour l'auto-hébergement)
• Ou un ordinateur de bureau (macOS/Windows/Linux) pour l'application native
• GPU recommandé pour un TTS en temps réel : NVIDIA avec 4 Go+ VRAM, Apple Silicon, ou carte compatible AMD ROCm
• Au moins 8 Go de RAM (16 Go recommandés pour une utilisation multi-moteurs)
• Un domaine ou une IP pour accéder à l'interface web (optionnel, pour le déploiement Docker)
• Proxy inverse (Nginx, Caddy, Traefik) pour TLS si exposition publique

Guide d'Installation Pas à Pas (Docker)

Étape 1 : Créer le Répertoire du Projet

mkdir -p voicebox/output && cd voicebox

Étape 2 : Créer docker-compose.yml

Créez un fichier docker-compose.yml :

services:
  voicebox:
    build: https://github.com/jamiepine/voicebox.git
    container_name: voicebox
    restart: unless-stopped
    ports:
      - "127.0.0.1:17493:17493"
    volumes:
      - ./output:/app/data/generations
      - voicebox-data:/app/data
      - huggingface-cache:/home/voicebox/.cache/huggingface
    environment:
      - LOG_LEVEL=info
      - NUMBA_CACHE_DIR=/tmp/numba_cache
    deploy:
      resources:
        limits:
          cpus: '4'
          memory: 8G

networks:
  voicebox-net:
    driver: bridge

volumes:
  voicebox-data:
  huggingface-cache:

Note : Pour l'accélération GPU, ajoutez deploy.resources.reservations.devices à votre fichier compose. Consultez la documentation Docker de Voicebox pour les configurations GPU spécifiques.

Étape 3 : Démarrer Voicebox

docker compose up -d

Au premier lancement, Voicebox téléchargera les fichiers de modèles nécessaires (moteurs TTS, Whisper, LLM Qwen3). Cela peut prendre 5 à 15 minutes selon votre connexion internet et les moteurs utilisés.

Étape 4 : Accéder à l'Interface Web

Ouvrez votre navigateur et accédez à :

http://localhost:17493

L'assistant de premier démarrage vous guidera à travers :

1. La sélection de votre moteur TTS par défaut
2. Le téléchargement des modèles
3. La création de votre premier profil vocal (téléchargez un court échantillon audio ou choisissez une voix prédéfinie)

Étape 5 : Créer Votre Premier Profil Vocal

1. Cliquez sur Profils dans la barre latérale
2. Cliquez sur Nouveau Profil
3. Téléchargez un clip audio de 10 à 30 secondes (la parole claire fonctionne le mieux)
4. Entrez un nom pour le profil
5. Sélectionnez le format de votre source audio
6. Cliquez sur Créer

Voicebox traitera l'échantillon et générera un modèle vocal. Vous pouvez maintenant utiliser cette voix pour la génération TTS.

Étape 6 : Générer de la Parole

# Via l'API REST
curl -X POST http://127.0.0.1:17493/generate \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Bonjour le monde, c'est ma voix clonée qui parle !",
    "profile_id": "<votre-id-profil>",
    "language": "fr"
  }'

Ou utilisez l'interface web : naviguez vers Générer, sélectionnez votre profil vocal, tapez votre texte et cliquez sur le bouton de génération.

Connecter des Agents IA à Voicebox (MCP)

Voicebox intègre un serveur MCP pour que vos agents de codage IA puissent parler avec des voix clonées :

Claude Code

claude mcp add voicebox \
--transport http \
--url http://127.0.0.1:17493/mcp \
--header "X-Voicebox-Client-Id: claude-code"

Cursor / Windsurf / VS Code

Ajoutez à votre configuration mcpServers :

{
  "mcpServers": {
    "voicebox": {
      "url": "http://127.0.0.1:17493/mcp",
      "headers": { "X-Voicebox-Client-Id": "cursor" }
    }
  }
}

Ensuite, dans toute conversation avec un agent :

// L'agent appelle voicebox.speak pour produire un son
await voicebox.speak({
  text: "Construction terminée. Tous les tests passent.",
  profile: "Morgan"
});

Configuration

Variables d'Environnement

Répertoire des Modèles

Les modèles sont stockés dans le volume huggingface-cache et persistent entre les redémarrages du conteneur. Vous pouvez spécifier un chemin personnalisé avec la variable d'environnement VOICEBOX_MODELS_DIR.

Sélection du Moteur TTS

Voicebox supporte 7 moteurs TTS, chacun avec des forces différentes :

Changez de moteur par génération depuis l'interface web ou via le paramètre engine dans l'API.

Liste de Vérification

Une fois Voicebox en cours d'exécution, vérifiez que tout fonctionne :

• L'interface web charge à http://localhost:17493
• L'assistant de premier démarrage se termine avec succès
• Les modèles se téléchargent sans erreur
• Un profil vocal peut être créé à partir d'un échantillon audio
• La génération TTS produit de la parole audible
• L'API REST répond sur le port 17493
• Le serveur MCP répond à http://localhost:17493/mcp
• La dictée basée sur Whisper capture et transcrit l'audio
• Les effets audio (hauteur, réverbération) modifient la sortie comme prévu
• Les personnalités vocales génèrent du texte dans le caractère

Ressources

• GitHub: github.com/jamiepine/voicebox
• Documentation: docs.voicebox.sh
• Site web: voicebox.sh
• Téléchargements: github.com/jamiepine/voicebox/releases
• Dépannage: docs.voicebox.sh/overview/troubleshooting
• Licence: MIT