> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/voxtral-tts.md).

# Voxtral TTS

> **Le modèle texte-vers-parole open-weight de Mistral : 4 milliards de paramètres, 9 langues, clonage de voix zero-shot, seulement 3 Go de VRAM.**

| Spécification       | Valeur                                                                                |
| ------------------- | ------------------------------------------------------------------------------------- |
| **Développeur**     | Mistral AI                                                                            |
| **Paramètres**      | 4 milliards                                                                           |
| **Architecture**    | TTS uniquement décodeur                                                               |
| **Langues**         | 9 (anglais, français, allemand, espagnol, hindi, arabe, portugais, italien, japonais) |
| **Licence**         | Apache 2.0 (poids ouverts)                                                            |
| **VRAM**            | \~3 Go (FP16)                                                                         |
| **Latence**         | 70 ms pour une sortie de 10 secondes                                                  |
| **Clonage de voix** | Zero-shot à partir d’une référence de 3 secondes                                      |
| **Publication**     | 26 mars 2026                                                                          |

## Pourquoi Voxtral TTS ?

Voxtral TTS est la réponse open-weight de Mistral à ElevenLabs et OpenAI TTS. Principaux avantages pour les utilisateurs de Clore.ai :

* **Fonctionne sur n’importe quel GPU** — seulement 3 Go de VRAM, ce qui signifie même qu’une RTX 3060 fonctionne parfaitement
* **Aucun frais d’API** — auto-hébergé = synthèse illimitée à coût marginal nul
* **Confidentialité des données** — l’audio ne quitte jamais votre machine
* **Clonage zero-shot** — clonez n’importe quelle voix à partir de 3 secondes d’audio de référence
* **9 langues nativement** — y compris l’hindi et l’arabe, souvent absents chez les concurrents
* **Vitesse en temps réel** — RTF 0,1–0,2× sur RTX 4070+ (clip de 10 secondes en 1–2 secondes)

## Exigences GPU sur Clore.ai

| GPU            | VRAM  | Performance                                  | Prix Clore.ai           |
| -------------- | ----- | -------------------------------------------- | ----------------------- |
| RTX 3060 12 Go | 12 Go | ✅ Bon — 3–4× le temps réel                   | à partir de 0,10 $/jour |
| RTX 3090 24 Go | 24 Go | ✅ Excellent — traitement par lots            | à partir de 0,30 $/jour |
| RTX 4070 12 Go | 12 Go | ✅ Excellent — 5–10× le temps réel            | à partir de 0,25 $/jour |
| RTX 4090 24 Go | 24 Go | ✅ Excessif — latence inférieure à la seconde | à partir de 0,50 $/jour |

> **Recommandation :** Une RTX 3060 12 Go (0,10 $/jour sur Clore.ai) est le meilleur compromis pour la plupart des cas d’usage. Voxtral n’a besoin que de 3 Go de VRAM, vous pouvez donc l’exécuter en parallèle avec d’autres modèles.

## Démarrage rapide sur Clore.ai

### Étape 1 : Louer un serveur GPU

1. Allez sur [Clore.ai Marketplace](https://clore.ai/marketplace)
2. Filtrez pour n’importe quel GPU avec 8 Go de VRAM ou plus
3. Sélectionnez un **Docker** déploiement
4. Utilisez l’image : `pytorch/pytorch:2.4.0-cuda12.4-cudnn9-devel`

### Étape 2 : Installer les dépendances

```bash
# Connectez-vous via SSH ou le terminal Jupyter
pip install torch torchaudio transformers accelerate

# Installer le paquet Voxtral TTS
pip install voxtral-tts

# Ou utiliser HuggingFace directement
pip install huggingface_hub
huggingface-cli download mistralai/Voxtral-TTS --local-dir ./voxtral-tts
```

### Étape 3 : Synthèse vocale de base

```python
from voxtral import VoxtralTTS

# Initialiser le modèle (télécharge automatiquement les poids ~6 Go)
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS")
model.to("cuda")

# Synthèse de base
audio = model.synthesize(
    text="Bienvenue sur Clore.ai — la place de marché GPU décentralisée.",
    language="en"
)
audio.save("output.wav")
print(f"{audio.duration:.1f}s d’audio générés")
```

### Étape 4 : Clonage de voix zero-shot

```python
# Cloner une voix à partir d’une référence de 3 secondes
audio = model.synthesize(
    text="C’est ma voix clonée qui parle de l’informatique GPU.",
    reference_audio="reference_speaker.wav",  # 3+ secondes
    language="en"
)
audio.save("cloned_output.wav")
```

### Étape 5 : Synthèse multilingue

```python
# Synthétiser dans 9 langues prises en charge
languages = {
    "en": "Hello, this is Voxtral speaking in English.",
    "fr": "Bonjour, c'est Voxtral qui parle en français.",
    "de": "Hallo, hier spricht Voxtral auf Deutsch.",
    "es": "Hola, Voxtral hablando en español.",
    "hi": "नमस्ते, यह Voxtral हिंदी में बोल रहा है।",
    "ar": "مرحبا، هذا Voxtral يتحدث بالعربية.",
    "pt": "Olá, aqui é o Voxtral falando em português.",
    "it": "Ciao, qui parla Voxtral in italiano.",
    "ja": "こんにちは、Voxtralが日本語で話しています。",
}

for lang, text in languages.items():
    audio = model.synthesize(text=text, language=lang)
    audio.save(f"voxtral_{lang}.wav")
    print(f"[{lang}] {audio.duration:.1f}s générés")
```

## Serveur API de production

Déployez Voxtral comme API REST pour l’intégrer à vos applications :

```python
# server.py — wrapper FastAPI pour Voxtral TTS
from fastapi import FastAPI, UploadFile, File
from fastapi.responses import StreamingResponse
from voxtral import VoxtralTTS
import io
import soundfile as sf

app = FastAPI(title="API Voxtral TTS")
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

@app.post("/synthesize")
async def synthesize(
    text: str,
    language: str = "en",
    reference: UploadFile = File(None)
):
    kwargs = {"text": text, "language": language}
    if reference:
        ref_bytes = await reference.read()
        kwargs["reference_audio"] = ref_bytes
    
    audio = model.synthesize(**kwargs)
    
    # Retourner sous forme de flux WAV
    buffer = io.BytesIO()
    sf.write(buffer, audio.numpy(), samplerate=24000, format="WAV")
    buffer.seek(0)
    
    return StreamingResponse(buffer, media_type="audio/wav")

@app.get("/health")
async def health():
    return {"status": "ok", "model": "voxtral-tts", "languages": 9}
```

```bash
# Lancer le serveur API
pip install fastapi uvicorn python-multipart soundfile
uvicorn server:app --host 0.0.0.0 --port 8000

# Le tester
curl -X POST "http://localhost:8000/synthesize?text=Hello%20world&language=en" \
  --output hello.wav
```

## Déploiement Docker

```dockerfile
FROM pytorch/pytorch:2.4.0-cuda12.4-cudnn9-devel

WORKDIR /app
RUN pip install voxtral-tts fastapi uvicorn python-multipart soundfile

# Pré-télécharger les poids du modèle
RUN python -c "from voxtral import VoxtralTTS; VoxtralTTS.from_pretrained('mistralai/Voxtral-TTS')"

COPY server.py .
EXPOSE 8000
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]
```

```bash
# Construire et exécuter
docker build -t voxtral-tts-api .
docker run --gpus all -p 8000:8000 voxtral-tts-api
```

## Voxtral vs autres modèles TTS

| Fonctionnalité      | Voxtral TTS  | ElevenLabs       | Qwen3-TTS | Kokoro TTS | Fish Speech |
| ------------------- | ------------ | ---------------- | --------- | ---------- | ----------- |
| **Poids ouverts**   | ✅ Apache 2.0 | ❌ API uniquement | ✅         | ✅          | ✅           |
| **VRAM**            | 3 Go         | N/A (cloud)      | 8 Go      | 2 Go       | 4 Go        |
| **Langues**         | 9            | 30+              | 50+       | 5          | 8           |
| **Clonage de voix** | réf. 3 s     | réf. 1 s         | réf. 5 s  | ❌          | réf. 10 s   |
| **Latence**         | 70 ms        | \~200 ms         | \~150 ms  | 50 ms      | 100 ms      |
| **Qualité**         | ⭐⭐⭐⭐⭐        | ⭐⭐⭐⭐⭐            | ⭐⭐⭐⭐      | ⭐⭐⭐⭐       | ⭐⭐⭐⭐        |
| **Auto-hébergé**    | ✅            | ❌                | ✅         | ✅          | ✅           |

## Traitement par lots pour les grands projets

```python
import concurrent.futures
from voxtral import VoxtralTTS

model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

# Traiter un chapitre entier d’audiobook
paragraphs = [
    "Chapter 1: The Beginning...",
    "It was a dark and stormy night...",
    "The protagonist stepped forward...",
    # ... des centaines de paragraphes
]

def process_paragraph(idx_text):
    idx, text = idx_text
    audio = model.synthesize(text=text, language="en")
    audio.save(f"chapter1_part{idx:04d}.wav")
    return idx

# Traitement séquentiel (limité par le GPU)
for i, text in enumerate(paragraphs):
    process_paragraph((i, text))
    
print(f"{len(paragraphs)} paragraphes traités")
```

## Mode streaming pour les applications en temps réel

```python
# Synthèse en streaming pour les applications en direct
async def stream_synthesis(text: str, language: str = "en"):
    """Génère l’audio en segments streaming pour une lecture à faible latence."""
    model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")
    
    async for chunk in model.synthesize_stream(
        text=text,
        language=language,
        chunk_size=4096  # ~170 ms par segment à 24 kHz
    ):
        yield chunk.numpy().tobytes()
```

## Dépannage

| Problème                          | Solution                                                                                                          |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| OOM sur un petit GPU              | Utilisez `model.half()` pour FP16 (divise la VRAM par deux à \~1,5 Go)                                            |
| Première inférence lente          | Normal — le modèle compile les noyaux CUDA au premier lancement (\~30 s)                                          |
| Qualité médiocre pour la langue X | Assurez-vous d’utiliser le bon `langue` paramètre ; certaines langues nécessitent un audio de référence plus long |
| Artéfacts audio                   | Augmentez la `reference_audio` longueur à 5–10 s pour un meilleur clonage de voix                                 |
| Échec du téléchargement du modèle | Définissez `HF_TOKEN` variable d’environnement pour accéder au modèle protégé                                     |

## Analyse des coûts : Voxtral sur Clore.ai vs TTS cloud

| Service                  | 1 M caractères/mois | Remarques                                         |
| ------------------------ | ------------------- | ------------------------------------------------- |
| ElevenLabs Pro           | 99 $/mois           | 500 k caractères inclus, frais de dépassement     |
| OpenAI TTS               | 15 $/mois           | 15 $ par 1 M caractères                           |
| Google Cloud TTS         | 16 $/mois           | Voix standard                                     |
| **Voxtral sur Clore.ai** | **3–15 $/mois**     | RTX 3060 à 0,10–0,50 $/jour, caractères illimités |

> **En résumé :** Héberger Voxtral soi-même sur Clore.ai est 6 à 30 fois moins cher que les API TTS cloud, avec zéro limite de caractères et une confidentialité totale des données.

## Pour en savoir plus

* [Voxtral TTS sur HuggingFace](https://huggingface.co/mistralai/Voxtral-TTS)
* [Blog Mistral AI — Annonce de Voxtral](https://mistral.ai/news/voxtral-tts)
* [Comparer les modèles TTS sur Clore.ai](/guides/guides_v2-fr/comparaisons/tts-comparison.md)
* [Autres guides Audio et Voix](/guides/guides_v2-fr/audio-et-voix/audio-voice.md)

***

*Dernière mise à jour : 30 mars 2026*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/voxtral-tts.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.