> 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/kokoro-tts.md).

# Kokoro TTS

Führe Kokoro TTS aus — ein ultraleichtes Text-to-Speech-Modell mit 82M Parametern auf Clore.ai-GPUs.

Kokoro ist ein Text-to-Speech-Modell mit 82 Mio. Parametern, das weit über seiner Gewichtsklasse schlägt. Trotz seiner winzigen Größe (unter 2 GB VRAM) erzeugt es bemerkenswert natürliche englische Sprache und läuft selbst auf günstiger Hardware in Echtzeit oder noch schneller. Mit Apache-2.0-Lizenz, mehreren integrierten Sprachstilen und Unterstützung für CPU-Inferenz ist Kokoro ideal für Echtzeitanwendungen, Chatbots und Edge-Deployments.

**HuggingFace:** [hexgrad/Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) **PyPI:** [kokoro](https://pypi.org/project/kokoro/) **Lizenz:** Apache 2.0

## Hauptfunktionen

* **82 Mio. Parameter** — eines der kleinsten hochwertigen TTS-Modelle, die verfügbar sind
* **< 2 GB VRAM** — läuft auf praktisch jeder GPU und sogar auf der CPU
* **Mehrere Sprachstile** — amerikanisches Englisch, britisches Englisch; männliche und weibliche Stimmen
* **Echtzeit oder schneller** — Inferenz mit geringer Latenz, geeignet für Streaming
* **Streaming-Generierung** — gibt Audioschnipsel aus, sobald sie erzeugt werden
* **Unterstützung für mehrere Sprachen** — Englisch (primär), Japanisch (`misaki[ja]`), Chinesisch (`misaki[zh]`)
* **Apache 2.0** — kostenlos für private und kommerzielle Nutzung

## Anforderungen

| Komponente | Minimum               | Empfohlen |
| ---------- | --------------------- | --------- |
| GPU        | Jeder mit 2 GB VRAM   | RTX 3060  |
| VRAM       | 2 GB                  | 4 GB      |
| RAM        | 4 GB                  | 8 GB      |
| Festplatte | 500 MB                | 1 GB      |
| Python     | 3.9+                  | 3.11      |
| System     | espeak-ng installiert | —         |

**Clore.ai-Empfehlung:** Eine RTX 3060 ($0,03–0,07/Stunde) ist mehr als ausreichend. Kokoro kann sogar auf CPU-only-Instanzen laufen und ist damit extrem kosteneffizient für TTS.

## Installation

```bash
# Systemabhängigkeit installieren
apt-get install -y espeak-ng

# Kokoro und Audio-E/A installieren
pip install kokoro>=0.9.4 soundfile torch

# Für japanische Unterstützung (optional)
pip install misaki[ja]

# Für chinesische Unterstützung (optional)
pip install misaki[zh]

# Prüfen
python -c "from kokoro import KPipeline; print('Kokoro bereit')"
```

## Schnellstart

```python
from kokoro import KPipeline
import soundfile as sf

# Pipeline initialisieren
# 'a' = amerikanisches Englisch, 'b' = britisches Englisch
pipeline = KPipeline(lang_code='a')

text = """
Kokoro ist ein leichtgewichtiges Text-to-Speech-Modell mit nur zweiundachtzig Millionen
Parametern. Trotz seiner geringen Größe erzeugt es natürliche und ausdrucksstarke Sprache.
"""

# Audio erzeugen — Sprachoptionen: af_heart, af_bella, af_nicole, af_sarah, af_sky,
#                                  am_adam, am_michael, bf_emma, bf_isabella, bm_george, bm_lewis
generator = pipeline(text, voice='af_heart', speed=1.0)

for i, (graphemes, phonemes, audio) in enumerate(generator):
    sf.write(f'output_{i}.wav', audio, 24000)
    print(f"Chunk {i}: {graphemes[:50]}...")

print("Fertig!")
```

## Anwendungsbeispiele

### Mehrere Stimmen vergleichen

Erzeugen Sie denselben Text mit verschiedenen Stimmen, um sie zu vergleichen:

```python
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')

text = "Willkommen bei Clore.ai, dem Peer-to-Peer-GPU-Marktplatz."

voices = ['af_heart', 'af_bella', 'am_adam', 'am_michael']

for voice in voices:
    generator = pipeline(text, voice=voice, speed=1.0)
    for i, (gs, ps, audio) in enumerate(generator):
        sf.write(f'{voice}_{i}.wav', audio, 24000)
    print(f"Generiert: {voice}")
```

### Britisches Englisch mit Geschwindigkeitssteuerung

```python
from kokoro import KPipeline
import soundfile as sf

# 'b' = britisches Englisch
pipeline = KPipeline(lang_code='b')

text = "Guten Nachmittag. Dies ist eine Demonstration der Synthese in britischem Englisch."

# speed < 1.0 = langsamer, speed > 1.0 = schneller
generator = pipeline(text, voice='bf_emma', speed=0.85)

all_audio = []
for gs, ps, audio in generator:
    all_audio.append(audio)

import numpy as np
combined = np.concatenate(all_audio)
sf.write('british_slow.wav', combined, 24000)
print(f"Gesamtdauer: {len(combined)/24000:.1f}s")
```

### Stapelverarbeitung von Dateien

Verarbeiten Sie mehrere Texte und fügen Sie sie zu einer einzelnen Datei im Hörbuch-Stil zusammen:

```python
from kokoro import KPipeline
import soundfile as sf
import numpy as np

pipeline = KPipeline(lang_code='a')

chapters = [
    "Kapitel eins. Der Anfang unserer Reise beginnt hier.",
    "Die Sonne ging über den Bergen auf und warf lange Schatten über das Tal.",
    "Sie öffnete die Tür und trat ins Unbekannte.",
]

all_audio = []
silence = np.zeros(int(24000 * 0.5))  # 0,5 s Stille zwischen den Kapiteln

for idx, text in enumerate(chapters):
    for gs, ps, audio in pipeline(text, voice='af_bella', speed=1.0):
        all_audio.append(audio)
    all_audio.append(silence)
    print(f"Kapitel {idx+1} fertig")

combined = np.concatenate(all_audio)
sf.write('audiobook.wav', combined, 24000)
print(f"Gesamt: {len(combined)/24000:.1f}s")
```

## Tipps für Clore.ai-Nutzer

* **CPU-Inferenz** — Kokoro ist klein genug, um auf der CPU zu laufen; nützlich für kostensensible Workloads oder wenn keine GPUs verfügbar sind
* **Streaming** — der Generator gibt Audioschnipsel aus, sobald sie erzeugt werden, und ermöglicht so Echtzeitwiedergabe in Web-Apps
* **Mit WhisperX kombinieren** — verwenden Sie WhisperX für die Transkription und Kokoro für die Neusynthese in Sprachpipelines
* **Docker** — verwenden Sie `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime` und füge `apt-get install -y espeak-ng` für Ihr Startup
* **Stimmkonsistenz** — verwenden Sie pro Projekt eine einzige Stimm-ID, um ein konsistentes Erzählererlebnis zu gewährleisten
* **Kosteneffizienz** — mit $0,03–0,07/Stunde auf einer RTX 3060 ist Kokoro eine der günstigsten TTS-Lösungen zum Selbsthosten

## Fehlerbehebung

| Problem                                 | Lösung                                                                                                                  |
| --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `espeak-ng nicht gefunden`              | Ausführen `apt-get install -y espeak-ng` (erforderliche Systemabhängigkeit)                                             |
| `ModuleNotFoundError: kokoro`           | Installieren mit `pip install kokoro>=0.9.4 soundfile`                                                                  |
| Audio klingt roboterhaft                | Probieren Sie eine andere Stimme aus (z. B. `af_heart` klingt meist am natürlichsten)                                   |
| Japanisch/Chinesisch funktioniert nicht | Sprach-Extras installieren: `pip install misaki[ja]` oder `misaki[zh]`                                                  |
| Zu wenig Speicher auf der CPU           | Reduzieren Sie die Textlänge pro Aufruf; Kokoro streamt die Chunks, sodass der Speicherverbrauch begrenzt bleibt        |
| Langsamer erster Lauf                   | Die Modellgewichte werden bei der ersten Verwendung heruntergeladen (\~200 MB); nachfolgende Ausführungen sind sofortig |


---

# 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/kokoro-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.