> 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/kani-tts.md). # Kani-TTS-2-Stimmklonung Führe Kani-TTS-2 aus — ein ultraeffizientes Text-to-Speech-Modell mit 400M Parametern und Stimmklonung auf Clore.ai-GPUs Kani-TTS-2 von nineninesix.ai (veröffentlicht am 15. Februar 2026) ist ein Open-Source-Text-zu-Sprache-Modell mit 400 Mio. Parametern, das hochwertige Sprachsynthese mit nur **3 GB VRAM**. Auf Basis der LFM2-Architektur von LiquidAI mit NVIDIA NanoCodec behandelt es Audio als Sprache — und erzeugt natürlich klingende Sprache mit Zero-Shot-Stimmklonen aus einem kurzen Referenzaudioausschnitt. Mit weniger als der halben Größe konkurrierender Modelle und einem Bruchteil des Rechenaufwands ist Kani-TTS-2 perfekt für Echtzeit-Konversations-KI, Hörbucherstellung und Stimmklonen auf günstiger 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 ## Hauptfunktionen * **400 Mio. Parameter, 3 GB VRAM** — läuft auf praktisch jeder modernen GPU, einschließlich RTX 3060 * **Zero-Shot-Stimmenklonierung** — klone jede Stimme aus einem Referenzaudio von 3–30 Sekunden * **Sprecher-Embeddings** — WavLM-basierte 128-dimensionale Sprecherrepräsentationen für präzise Sprachsteuerung * **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 private und kommerzielle Nutzung * **Pretraining-Framework enthalten** — trainiere dein eigenes TTS-Modell von Grund auf in jeder Sprache ## Vergleich mit anderen TTS-Modellen | Modell | Parameter | Min. VRAM | Stimmenklonierung | Sprache | Lizenz | | -------------- | --------- | --------- | ------------------------- | ---------------------- | ------------ | | **Kani-TTS-2** | 400 Mio. | 3GB | ✅ Zero-Shot | Englisch (erweiterbar) | Apache 2.0 | | Kokoro | 82 Mio. | 2GB | ❌ Voreingestellte Stimmen | EN, JP, CN | Apache 2.0 | | Zonos | 400 Mio. | 8 GB | ✅ | Mehrere GPUs | Apache 2.0 | | ChatTTS | 300 Mio. | 4 GB | ❌ Zufallsseeds | Chinesisch, Englisch | AGPL 3.0 | | Chatterbox | 500 Mio. | 6 GB | ✅ | Englisch | Apache 2.0 | | XTTS (Coqui) | 467 Mio. | 6 GB | ✅ | Mehrere GPUs | MPL 2.0 | | F5-TTS | 335M | 4 GB | ✅ | Mehrere GPUs | CC-BY-NC 4.0 | ## Anforderungen {% hint style="warning" %} **Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst. {% endhint %} | Komponente | Minimum | Empfohlen | | ---------- | ------------------ | -------------------- | | GPU | Jede mit 3 GB VRAM | RTX 3060 oder besser | | VRAM | 3GB | 6 GB | | RAM | 8 GB | 16 GB | | Festplatte | 2GB | 5 GB | | Python | 3.9+ | 3.11+ | | CUDA | 12.8+ | 12.8+ | **Clore.ai-Empfehlung:** Eine RTX 3060 ($0,03–0,07/Stunde) reicht vollkommen aus. Selbst die günstigsten GPU-Instanzen auf Clore.ai können Kani-TTS-2 problemlos ausführen. Für die Stapelverarbeitung (Hörbücher, Datensätze) bietet eine RTX 4090 ($0,14–0,42/Stunde) einen hervorragenden Durchsatz. ## Installation ```bash # Paket installieren pip install kani-tts-2 # WICHTIG: Kompatible Transformers-Version installieren (erforderlich für die 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 erzeugen audio, text = model("Hallo! Willkommen bei Kani TTS 2, der nächsten Generation effizienter Text-zu-Sprache.") # In Datei speichern model.save_audio(audio, "output.wav") ``` ## Anwendungsbeispiele ### 1. Grundlegende Text-zu-Sprache ```python from kani_tts import KaniTTS model = KaniTTS('nineninesix/kani-tts-2-en') # Mit benutzerdefinierten Parametern erzeugen audio, text = model( "Der flinke braune Fuchs springt über den faulen Hund. " "Dieser Satz enthält jeden Buchstaben des englischen Alphabets.", temperature=0.7, top_p=0.9, repetition_penalty=1.1 ) model.save_audio(audio, "pangram.wav") print(f"{len(audio) / 22000:.1f} Sekunden Audio erzeugt") ``` ### 2. Stimmklonen Klonen Sie jede Stimme aus einem kurzen Referenzaudioausschnitt: ```python from kani_tts import KaniTTS, SpeakerEmbedder # Modelle initialisieren model = KaniTTS('nineninesix/kani-tts-2-en') embedder = SpeakerEmbedder() # Sprecher-Embedding aus Referenzaudio extrahieren (3–30 Sekunden empfohlen) speaker_embedding = embedder.embed_audio_file("reference_voice.wav") # Sprache in der geklonten Stimme erzeugen audio, text = model( "Dies ist eine Demonstration des Stimmklonens mit Kani TTS 2. " "Die Stimme, die Sie hören, sollte mit dem Referenzaudioausschnitt übereinstimmen.", speaker_emb=speaker_embedding ) model.save_audio(audio, "cloned_output.wav") ``` ### 3. Stapelgenerierung 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 Apriltag, und die Uhren schlugen dreizehn.", "Kapitel Zwei. Der Flur roch nach gekochtem Kohl und alten Fußmatten.", "Kapitel Drei. Draußen wirkte selbst durch die geschlossene Fensterscheibe 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"Kapitel {i+1} erzeugt") ``` ### 4. OpenAI-kompatible Streaming-API Für Echtzeitanwendungen den OpenAI-kompatiblen Server verwenden: ```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 ``` Dann mit jedem beliebigen OpenAI-TTS-Client verwenden: ```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="Hallo vom OpenAI-kompatiblen Kani-TTS-Server!" ) response.stream_to_file("streamed_output.wav") ``` ## Tipps für Clore.ai-Nutzer 1. **Dies ist das günstigste Modell zum Ausführen** — Mit 3 GB VRAM läuft Kani-TTS-2 auf buchstäblich jeder GPU-Instanz auf Clore.ai. Eine RTX 3060 für $0,03–0,07/Stunde ist für produktives TTS mehr als ausreichend. 2. **Mit einem Sprachmodell kombinieren** — Miete eine GPU-Instanz und betreibe gleichzeitig ein kleines LLM (z. B. Mistral 3 8B) und Kani-TTS-2 für einen vollständigen Sprachassistenten. Sie teilen sich die GPU mit reichlich Reserve. 3. **Sprecher-Embeddings vorab berechnen** — Extrahiere Sprecher-Embeddings einmal und speichere sie. Dadurch entfällt das Laden des WavLM-Embedders bei jeder Anfrage. 4. **Den OpenAI-kompatiblen Server verwenden** — Der `kani-tts-2-openai-server` bietet einen direkten Ersatz für die OpenAI-TTS-API und lässt sich dadurch leicht in bestehende Anwendungen integrieren. 5. **Auf benutzerdefinierten 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)). Fine-tune das Modell auf deinem eigenen Sprachdatensatz — dafür brauchst du nur 8× H100s für etwa 6 Stunden. ## Fehlerbehebung | Problem | Lösung | | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | `ImportError: LFM2 kann nicht importiert werden` | Installieren Sie die richtige Transformers-Version: `pip install -U "transformers==4.56.0"` | | Die Audioqualität ist schlecht / klingt robotisch | Erhöhen Sie `temperature` auf 0,8–0,9; stellen Sie sicher, dass das Referenzaudio für das Klonen sauber ist (kein Hintergrundrauschen) | | Stimmklonen klingt nicht wie die Referenz | Verwenden Sie 5–15 Sekunden klares Audio mit nur einer Sprecherstimme. Vermeiden Sie Musik oder Hintergrundrauschen in der Referenz | | `CUDA-Speicher erschöpft` | Sollte bei einem 3-GB-Modell nicht passieren — prüfen Sie, ob andere Prozesse den GPU-Speicher verwenden (`nvidia-smi`) | | Audio bricht mitten im Satz ab | Kani-TTS-2 unterstützt bis zu etwa 40 Sekunden. Teilen Sie längere Texte in Sätze auf und fügen Sie 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, fortgeschrittene Beispiele * [HuggingFace — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — Gewichte des englischen Modells * [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) — Direkter Ersatz für die OpenAI-TTS-API * [Sprecher-Embedding-Modell](https://huggingface.co/nineninesix/speaker-emb-tbr) — WavLM-basierter Stimm-Embeddder * [MarkTechPost-Überblick](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/) — Berichterstattung aus der Community --- # 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/kani-tts.md?ask=&goal= ``` `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.