> 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-de/audio-and-stimme/voxtral-tts.md).

# Voxtral TTS

> **Mistrals Open-Weight-Text-to-Speech-Modell: 4 Mrd. Parameter, 9 Sprachen, Zero-Shot-Stimmenklonen, nur 3 GB VRAM.**

| Spezifikation        | Wert                                                                                                 |
| -------------------- | ---------------------------------------------------------------------------------------------------- |
| **Entwickler**       | Mistral AI                                                                                           |
| **Parameter**        | 4 Milliarden                                                                                         |
| **Architektur**      | Nur-Decoder-TTS                                                                                      |
| **Sprachen**         | 9 (Englisch, Französisch, Deutsch, Spanisch, Hindi, Arabisch, Portugiesisch, Italienisch, Japanisch) |
| **Lizenz**           | Apache 2.0 (Open Weights)                                                                            |
| **VRAM**             | \~3 GB (FP16)                                                                                        |
| **Latenz**           | 70 ms für eine 10-Sekunden-Ausgabe                                                                   |
| **Stimmenklonen**    | Zero-Shot aus 3-Sekunden-Referenz                                                                    |
| **Veröffentlichung** | 26. März 2026                                                                                        |

## Warum Voxtral TTS?

Voxtral TTS ist Mistrals Open-Weight-Antwort auf ElevenLabs und OpenAI TTS. Wichtige Vorteile für Clore.ai-Nutzer:

* **Läuft auf jeder GPU** — nur 3 GB VRAM bedeuten, dass sogar eine RTX 3060 einwandfrei funktioniert
* **Keine API-Gebühren** — selbst gehostet = unbegrenzte Synthese ohne Grenzkosten
* **Datenschutz** — Audio verlässt nie Ihren Rechner
* **Zero-Shot-Klonen** — klone jede Stimme anhand von 3 Sekunden Referenz-Audio
* **9 Sprachen nativ** — einschließlich Hindi und Arabisch, die bei Wettbewerbern oft fehlen
* **Echtzeitgeschwindigkeit** — RTF 0,1–0,2× auf RTX 4070+ (10-Sekunden-Clip in 1–2 Sekunden)

## GPU-Anforderungen auf Clore.ai

| GPU            | VRAM  | Leistung                                | Clore.ai-Preis      |
| -------------- | ----- | --------------------------------------- | ------------------- |
| RTX 3060 12 GB | 12 GB | ✅ Gut — 3–4× Echtzeit                   | ab 0,03–0,07 $/Std. |
| RTX 3090 24 GB | 24 GB | ✅ Großartig — Stapelverarbeitung        | ab 0,07–0,21 $/Std. |
| RTX 4070 12GB  | 12 GB | ✅ Hervorragend — 5–10× Echtzeit         | ab 0,04–0,20 $/Std. |
| RTX 4090 24GB  | 24 GB | ✅ Overkill — Latenz unter einer Sekunde | ab 0,14–0,42 $/Std. |

> **Empfehlung:** Eine RTX 3060 12GB (0,03–0,07 $/Std. auf Clore.ai) ist der Sweet Spot für die meisten Anwendungsfälle. Voxtral benötigt nur 3 GB VRAM, sodass Sie es neben anderen Modellen ausführen können.

## Schnellstart auf Clore.ai

### Schritt 1: Miete einen GPU-Server

1. Gehe zu [Clore.ai-Marktplatz](https://clore.ai/marketplace)
2. Filtere nach jeder GPU mit 8+ GB VRAM
3. Wähle eine **Docker** Bereitstellung
4. Verwende das Image: `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel`

### Schritt 2: Abhängigkeiten installieren

```bash
# Verbinden Sie sich per SSH oder über das Jupyter-Terminal
pip install torch torchaudio transformers accelerate

# Voxtral-TTS-Paket installieren
pip install voxtral-tts

# Oder direkt HuggingFace verwenden
pip install huggingface_hub
huggingface-cli download mistralai/Voxtral-TTS --local-dir ./voxtral-tts
```

### Schritt 3: Einfache Text-zu-Sprache

```python
from voxtral import VoxtralTTS

# Modell initialisieren (lädt Gewichte automatisch herunter, ~6 GB)
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS")
model.to("cuda")

# Einfache Synthese
audio = model.synthesize(
    text="Willkommen bei Clore.ai — dem dezentralen GPU-Marktplatz.",
    language="en"
)
audio.save("output.wav")
print(f"{audio.duration:.1f}s Audio generiert")
```

### Schritt 4: Zero-Shot-Stimmenklonen

```python
# Stimme anhand einer 3-Sekunden-Referenz klonen
audio = model.synthesize(
    text="Das ist meine geklonte Stimme, die über GPU-Computing spricht.",
    reference_audio="reference_speaker.wav",  # 3+ Sekunden
    language="en"
)
audio.save("cloned_output.wav")
```

### Schritt 5: Mehrsprachige Synthese

```python
# In 9 unterstützten Sprachen synthetisieren
languages = {
    "en": "Hallo, hier spricht Voxtral auf Englisch.",
    "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 generiert")
```

## Produktions-API-Server

Stellen Sie Voxtral als REST-API zur Integration in Ihre Anwendungen bereit:

```python
# server.py — FastAPI-Wrapper für 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="Voxtral-TTS-API")
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)
    
    # Als WAV-Stream zurückgeben
    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
# Den API-Server starten
pip install fastapi uvicorn python-multipart soundfile
uvicorn server:app --host 0.0.0.0 --port 8000

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

## Docker-Bereitstellung

```dockerfile
FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

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

# Modellgewichte vorab herunterladen
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
# Bauen und ausführen
docker build -t voxtral-tts-api .
docker run --gpus all -p 8000:8000 voxtral-tts-api
```

## Voxtral vs. andere TTS-Modelle

| Funktion            | Voxtral TTS  | ElevenLabs   | Qwen3-TTS    | Kokoro TTS | Fish Speech   |
| ------------------- | ------------ | ------------ | ------------ | ---------- | ------------- |
| **Offene Gewichte** | ✅ Apache 2.0 | ❌ Nur API    | ✅            | ✅          | ✅             |
| **VRAM**            | 3 GB         | N/A (Cloud)  | 8 GB         | 2 GB       | 4 GB          |
| **Sprachen**        | 9            | 30+          | 50+          | 5          | 8             |
| **Stimmenklonen**   | 3 s Referenz | 1 s Referenz | 5 s Referenz | ❌          | 10 s Referenz |
| **Latenz**          | 70 ms        | \~200 ms     | \~150 ms     | 50 ms      | 100 ms        |
| **Qualität**        | ⭐⭐⭐⭐⭐        | ⭐⭐⭐⭐⭐        | ⭐⭐⭐⭐         | ⭐⭐⭐⭐       | ⭐⭐⭐⭐          |
| **Selbst gehostet** | ✅            | ❌            | ✅            | ✅          | ✅             |

## Stapelverarbeitung für große Projekte

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

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

# Ein komplettes Hörbuch-Kapitel verarbeiten
paragraphs = [
    "Kapitel 1: Der Anfang...",
    "Es war eine dunkle und stürmische Nacht...",
    "Die Hauptfigur trat vor...",
    # ... Hunderte von Absätzen
]

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

# Sequenzielle Verarbeitung (GPU-gebunden)
for i, text in enumerate(paragraphs):
    process_paragraph((i, text))
    
print(f"{len(paragraphs)} Absätze verarbeitet")
```

## Streaming-Modus für Echtzeit-Anwendungen

```python
# Streaming-Synthese für Live-Anwendungen
async def stream_synthesis(text: str, language: str = "en"):
    """Audio in Streaming-Blöcken für die Wiedergabe mit geringer Latenz erzeugen."""
    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 pro Chunk bei 24 kHz
    ):
        yield chunk.numpy().tobytes()
```

## Fehlerbehebung

| Problem                          | Lösung                                                                                             |
| -------------------------------- | -------------------------------------------------------------------------------------------------- |
| OOM auf kleiner GPU              | Verwende `model.half()` für FP16 (halbiert den VRAM auf \~1,5 GB)                                  |
| Langsame erste Inferenz          | Normal — das Modell kompiliert beim ersten Lauf CUDA-Kerne (\~30 s)                                |
| Schlechte Qualität für Sprache X | Stelle den richtigen `Sprache` Parameter sicher; einige Sprachen benötigen längeres Referenz-Audio |
| Audio-Artefakte                  | Erhöhen Sie `reference_audio` Länge auf 5–10 s für besseres Stimmenklonen                          |
| Modell-Download schlägt fehl     | Setze `HF_TOKEN` Umgebungsvariable für den Zugriff auf das geschützte Modell                       |

## Kostenanalyse: Voxtral auf Clore.ai vs. Cloud-TTS

| Dienst                   | 1 Mio. Zeichen/Monat | Hinweise                                              |
| ------------------------ | -------------------- | ----------------------------------------------------- |
| ElevenLabs Pro           | 99 $/Monat           | 500.000 Zeichen enthalten, Gebühren für Mehrverbrauch |
| OpenAI TTS               | 15 $/Monat           | 15 $ pro 1 Mio. Zeichen                               |
| Google Cloud TTS         | 16 $/Monat           | Standardstimmen                                       |
| **Voxtral auf Clore.ai** | **3–15 $/Monat**     | RTX 3060 zu 0,03–0,07 $/Std., unbegrenzte Zeichen     |

> **Fazit:** Selbsthosting von Voxtral auf Clore.ai ist 6–30× günstiger als Cloud-TTS-APIs, mit keinen Zeichenlimits und vollständigem Datenschutz.

## Weiterführende Lektüre

* [Voxtral TTS auf HuggingFace](https://huggingface.co/mistralai/Voxtral-TTS)
* [Mistral AI Blog — Voxtral-Ankündigung](https://mistral.ai/news/voxtral-tts)
* [Vergleiche TTS-Modelle auf Clore.ai](/guides/guides_v2-de/vergleiche/tts-comparison.md)
* [Weitere Audio- & Sprachleitfäden](/guides/guides_v2-de/audio-and-stimme/audio-voice.md)

***

*Zuletzt aktualisiert: 30. März 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/voxtral-tts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.