# 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 |


---

# Agent Instructions: 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-de/audio-and-sprache/kokoro-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.