# Kani-TTS-2 Stimmenklonung

Kani-TTS-2 von nineninesix.ai (veröffentlicht am 15. Februar 2026) ist ein Open-Source-Text-zu-Sprache-Modell mit 400 Millionen Parametern, das hochauflösende Sprachsynthese erreicht und dabei nur **3 GB VRAM**. Basierend auf LiquidAI's LFM2-Architektur mit NVIDIA NanoCodec behandelt es Audio wie eine Sprache — es erzeugt natürlich klingende Sprache mit Zero-Shot-Stimmenklonung aus einem kurzen Referenz-Audioclip. Bei weniger als der Hälfte der Größe konkurrierender Modelle und einem Bruchteil des Rechenaufwands ist Kani-TTS-2 ideal für Echtzeit-Konversations-KI, Hörbucherzeugung und Stimmenklonung auf sparsamer Hardware.

**HuggingFace:** [nineninesix/kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) **GitHub:** [nineninesix-ai/kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) **PyPI:** [kani-tts-2](https://pypi.org/project/kani-tts-2/) **Lizenz:** Apache 2.0

## Hauptmerkmale

* **400M Parameter, 3GB VRAM** — läuft praktisch auf jeder modernen GPU, einschließlich RTX 3060
* **Zero-Shot-Stimmenklonung** — klont jede Stimme aus einer 3–30 Sekunden langen Referenz-Audioprobe
* **Sprecher-Embeddings** — WavLM-basierte 128-dimensionale Sprecherrepräsentationen für präzise Stimmsteuerung
* **Bis zu 40 Sekunden kontinuierliches Audio** — geeignet für längere Passagen und Dialoge
* **Echtzeit oder schneller** — RTF \~0.2 auf RTX 5080, in Echtzeit sogar auf günstigen GPUs
* **Apache 2.0** — vollständig offen für persönliche und kommerzielle Nutzung
* **Pretraining-Framework enthalten** — trainiere dein eigenes TTS-Modell von Grund auf für jede Sprache

## Vergleich mit anderen TTS-Modellen

| Modell         | Parameter | Min. VRAM | Stimmenklon               | Sprache                | Lizenz       |
| -------------- | --------- | --------- | ------------------------- | ---------------------- | ------------ |
| **Kani-TTS-2** | 400M      | 3GB       | ✅ Zero-Shot               | Englisch (erweiterbar) | Apache 2.0   |
| Kokoro         | 82M       | 2GB       | ❌ Voreingestellte Stimmen | EN, JP, CN             | Apache 2.0   |
| Zonos          | 400M      | 8GB       | ✅                         | Multi                  | Apache 2.0   |
| ChatTTS        | 300M      | 4GB       | ❌ Zufällige Seeds         | Chinesisch, Englisch   | AGPL 3.0     |
| Chatterbox     | 500M      | 6GB       | ✅                         | Englisch               | Apache 2.0   |
| XTTS (Coqui)   | 467M      | 6GB       | ✅                         | Multi                  | MPL 2.0      |
| F5-TTS         | 335M      | 4GB       | ✅                         | Multi                  | CC-BY-NC 4.0 |

## Anforderungen

| Komponente | Minimum           | Empfohlen            |
| ---------- | ----------------- | -------------------- |
| GPU        | Jede mit 3GB VRAM | RTX 3060 oder besser |
| VRAM       | 3GB               | 6GB                  |
| RAM        | 8GB               | 16GB                 |
| Festplatte | 2GB               | 5GB                  |
| Python     | 3.9+              | 3.11+                |
| CUDA       | 11.8+             | 12.0+                |

**Clore.ai-Empfehlung:** Eine RTX 3060 (~~$0.15–0.30/Tag) ist mehr als ausreichend. Selbst die günstigsten GPU-Instanzen auf Clore.ai laufen Kani-TTS-2 problemlos. Für Batch-Verarbeitung (Hörbücher, Datensätze) bietet eine RTX 4090 (~~$0.5–2/Tag) ausgezeichneten Durchsatz.

## Installation

```bash
# Paket installieren
pip install kani-tts-2

# WICHTIG: Kompatible Transformers-Version installieren (erforderlich für LFM2-Architektur)
pip install -U "transformers==4.56.0"

# Optional: soundfile zum Speichern von Audio installieren
pip install soundfile
```

## Schnellstart

Drei Zeilen, um Sprache zu erzeugen:

```python
from kani_tts import KaniTTS

# Mit dem englischen Modell initialisieren
model = KaniTTS('nineninesix/kani-tts-2-en')

# Sprache generieren
audio, text = model("Hello! Welcome to Kani TTS 2, the next generation of efficient text-to-speech.")

# In Datei speichern
model.save_audio(audio, "output.wav")
```

## Beispielanwendungen

### 1. Grundlegendes Text-zu-Sprache

```python
from kani_tts import KaniTTS

model = KaniTTS('nineninesix/kani-tts-2-en')

# Mit benutzerdefinierten Parametern erzeugen
audio, text = model(
    "The quick brown fox jumps over the lazy dog. "
    "This sentence contains every letter of the English alphabet.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"Generated {len(audio) / 22000:.1f} seconds of audio")
```

### 2. Stimmenklonung

Klone jede Stimme aus einer kurzen Referenz-Audioprobe:

```python
from kani_tts import KaniTTS, SpeakerEmbedder

# Modelle initialisieren
model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Sprecher-Embedding aus Referenz-Audio extrahieren (3–30 Sekunden empfohlen)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# Sprache in der geklonten Stimme erzeugen
audio, text = model(
    "This is a demonstration of voice cloning with Kani TTS 2. "
    "The voice you hear should match the reference audio sample.",
    speaker_emb=speaker_embedding
)

model.save_audio(audio, "cloned_output.wav")
```

### 3. Batch-Erzeugung für Hörbücher

Mehrere Kapitel effizient erzeugen:

```python
from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Eine Erzählerstimme verwenden
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "Kapitel Eins. Es war ein heller kalter Tag im April, und die Uhren schlugen dreizehn.",
    "Kapitel Zwei. Der Flur roch nach gekochtem Kohl und alten Lumpenteppichen.",
    "Kapitel Drei. Draußen, selbst durch die geschlossene Fensterscheibe, wirkte die Welt kalt.",
]

for i, chapter_text in enumerate(chapters):
    audio, _ = model(chapter_text, speaker_emb=narrator_emb)
    model.save_audio(audio, f"chapter_{i+1}.wav")
    print(f"Generated chapter {i+1}")
```

### 4. OpenAI-kompatible Streaming-API

Für Echtzeitanwendungen verwende den OpenAI-kompatiblen Server:

```bash
# Server klonen
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# Abhängigkeiten installieren
pip install -r requirements.txt

# Server starten
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080
```

Verwende ihn dann mit jedem OpenAI-TTS-Client:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")

response = client.audio.speech.create(
    model="kani-tts-2-en",
    voice="default",
    input="Hello from the OpenAI-compatible Kani TTS server!"
)

response.stream_to_file("streamed_output.wav")
```

## Tipps für Clore.ai-Nutzer

1. **Dies ist das günstigste Modell zum Betreiben** — Mit 3GB VRAM läuft Kani-TTS-2 buchstäblich auf jeder GPU-Instanz bei Clore.ai. Eine RTX 3060 für $0.15/Tag ist mehr als ausreichend für Produktions-TTS.
2. **Mit einem Sprachmodell kombinieren** — Miete eine GPU-Instanz und betreibe sowohl ein kleines LLM (z. B. Mistral 3 8B) als auch Kani-TTS-2 gleichzeitig für einen vollständigen Sprachassistenten. Sie teilen sich die GPU mit Spielraum.
3. **Sprecher-Embeddings vorab berechnen** — Extrahiere Sprecher-Embeddings einmal und speichere sie. So muss das WavLM-Embedder-Modell nicht bei jeder Anfrage geladen werden.
4. **Verwende den OpenAI-kompatiblen Server** — Der `kani-tts-2-openai-server` bietet einen Drop-in-Ersatz für OpenAIs TTS-API und erleichtert die Integration in bestehende Anwendungen.
5. **Auf benutzerdefinierte Sprachen trainieren** — Kani-TTS-2 enthält ein vollständiges Pretraining-Framework ([kani-tts-2-pretrain](https://github.com/nineninesix-ai/kani-tts-2-pretrain)). Feintune das Modell auf deinem eigenen Sprachdatensatz — es benötigt nur 8× H100s für \~6 Stunden.

## Fehlerbehebung

| Problem                                          | Lösung                                                                                                                        |
| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
| `ImportError: kann LFM2 nicht importieren`       | Installiere die korrekte Transformers-Version: `pip install -U "transformers==4.56.0"`                                        |
| Audioqualität ist schlecht / robotisch           | Erhöhen Sie `temperature` auf 0.8–0.9; stelle sicher, dass Referenzaudio für das Klonen sauber ist (kein Hintergrundgeräusch) |
| Die Stimmenklonung klingt nicht wie die Referenz | Verwende 5–15 Sekunden klares, einsprachiges Audio. Vermeide Musik oder Hintergrundgeräusche in der Referenz                  |
| `CUDA out of memory`                             | Sollte beim 3GB-Modell nicht passieren — prüfe, ob andere Prozesse GPU-Speicher nutzen (`nvidia-smi`)                         |
| Audio bricht mitten im Satz ab                   | Kani-TTS-2 unterstützt bis zu \~40 Sekunden. Teile längere Texte in Sätze auf und füge die Ausgaben zusammen                  |
| Langsam auf der CPU                              | GPU-Inferenz wird dringend empfohlen. Selbst eine einfache GPU ist 10–50× schneller als die CPU                               |

## Weiterführende Lektüre

* [GitHub — kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) — PyPI-Paket, Nutzungsdokumentation, erweiterte Beispiele
* [HuggingFace — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — Englische Modellgewichte
* [Pretraining-Framework](https://github.com/nineninesix-ai/kani-tts-2-pretrain) — Trainiere dein eigenes TTS-Modell von Grund auf
* [OpenAI-kompatibler Server](https://github.com/nineninesix-ai/kani-tts-2-openai-server) — Drop-in-Ersatz für OpenAI TTS-API
* [Sprecher-Embedding-Modell](https://huggingface.co/nineninesix/speaker-emb-tbr) — WavLM-basiertes Voice-Embedder
* [MarkTechPost-Übersicht](https://www.marktechpost.com/2026/02/15/meet-kani-tts-2-a-400m-param-open-source-text-to-speech-model-that-runs-in-3gb-vram-with-voice-cloning-support/) — Community-Berichterstattung