# Kokoro TTS

Kokoro ist ein 82M-Parameter Text-zu-Sprache-Modell, das weit über seine Gewichtsklasse hinaus performt. Trotz seiner winzigen Größe (unter 2 GB VRAM) erzeugt es bemerkenswert natürlich klingende englische Sprache und läuft in Echtzeit oder schneller sogar auf günstiger Hardware. Mit Apache-2.0-Lizenz, mehreren integrierten Stimmenstilen und CPU-Inferenzunterstützung ist Kokoro ideal für Echtzeit-Anwendungen, 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

## Hauptmerkmale

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

## Anforderungen

| Komponente | Minimum               | Empfohlen |
| ---------- | --------------------- | --------- |
| GPU        | Jede 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,15–0,30 $/Tag) ist mehr als ausreichend. Kokoro kann sogar auf reinen CPU-Instanzen laufen und bietet so extrem kostengünstiges TTS.

## Installation

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

# Kokoro und Audio-I/O installieren
pip install kokoro>=0.9.4 soundfile torch

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

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

# Verifizieren
python -c "from kokoro import KPipeline; print('Kokoro ready')"
```

## 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-zu-Sprache-Modell mit nur zweiundachtzig Millionen
Parametern. Trotz seiner geringen Größe erzeugt es natürliche und ausdrucksstarke Sprache.
"""

# Audio generieren — Stimmenoptionen: 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!")
```

## Beispielanwendungen

### Vergleich mehrerer Stimmen

Erzeuge denselben Text mit unterschiedlichen Stimmen zum Vergleich:

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

pipeline = KPipeline(lang_code='a')

text = "Welcome to Clore.ai, the peer-to-peer GPU marketplace."

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"Generated: {voice}")
```

### Britisches Englisch mit Geschwindigkeitskontrolle

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

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

text = "Good afternoon. This is a demonstration of British English synthesis."

# 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")
```

### Batch-Dateiverarbeitung

Verarbeite mehrere Texte und füge sie zu einer einzelnen Hörbuch-ähnlichen Datei zusammen:

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

pipeline = KPipeline(lang_code='a')

chapters = [
    "Kapitel eins. Der Beginn 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,5s 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"Insgesamt: {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 kostenempfindliche Workloads oder wenn GPUs nicht verfügbar sind
* **Streaming** — der Generator liefert Audiobrocken, sobald sie erzeugt werden, was Echtzeitwiedergabe in Web-Apps ermöglicht
* **Mit WhisperX kombinieren** — verwende WhisperX zur Transkription und Kokoro zur Re-Synthese in Sprachpipelines
* **Docker** — verwenden Sie `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime` und füge hinzu `apt-get install -y espeak-ng` zu deinem Startup
* **Stimmkonsistenz** — bleibe bei einer Voice-ID pro Projekt für ein konsistentes Erzähler-Erlebnis
* **Kosteneffizienz** — bei 0,15 $/Tag 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`           | Installiere mit `pip install kokoro>=0.9.4 soundfile`                                                           |
| Audio klingt robotisch                  | Probiere eine andere Stimme (z. B., `af_heart` neigt dazu, am natürlichsten zu klingen)                         |
| Japanisch/Chinesisch funktioniert nicht | Installiere Sprach-Extras: `pip install misaki[ja]` oder `misaki[zh]`                                           |
| Zu wenig Speicher auf der CPU           | Reduziere die Textlänge pro Aufruf; Kokoro streamt Brocken, sodass der Speicher begrenzt bleibt                 |
| Langsamer erster Lauf                   | Modellgewichte werden beim ersten Gebrauch heruntergeladen (\~200 MB); nachfolgende Läufe sind sofort verfügbar |