> 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-hi/audio-and-voice/kani-tts.md).

# Kani-TTS-2 वॉइस क्लोनिंग

Clore.ai GPUs पर वॉइस क्लोनिंग के साथ Kani-TTS-2 — एक अल्ट्रा-कुशल 400M पैरामीटर टेक्स्ट-टू-स्पीच मॉडल — चलाएँ

nineninesix.ai का Kani-TTS-2 (15 फ़रवरी, 2026 को जारी) 400M-पैरामीटर वाला ओपन-सोर्स टेक्स्ट-टू-स्पीच मॉडल है, जो केवल **3GB VRAM**. LiquidAI की LFM2 आर्किटेक्चर और NVIDIA NanoCodec पर आधारित, यह ऑडियो को एक भाषा की तरह मानता है — एक छोटे संदर्भ ऑडियो क्लिप से शून्य-शॉट वॉइस क्लोनिंग के साथ स्वाभाविक-सा लगने वाला भाषण उत्पन्न करता है। प्रतिस्पर्धी मॉडलों के आधे से भी कम आकार और बहुत कम गणना के साथ, Kani-TTS-2 रीयल-टाइम कन्वर्सेशनल AI, ऑडियोबुक जनरेशन, और बजट हार्डवेयर पर वॉइस क्लोनिंग के लिए बिल्कुल उपयुक्त है।

**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/) **लाइसेंस:** Apache 2.0

## मुख्य विशेषताएँ

* **400M पैरामीटर, 3GB VRAM** — RTX 3060 सहित, लगभग किसी भी आधुनिक GPU पर चलता है
* **ज़ीरो-शॉट वॉइस क्लोनिंग** — 3–30 सेकंड के संदर्भ ऑडियो सैंपल से किसी भी आवाज़ को क्लोन करें
* **स्पीकर एम्बेडिंग** — सटीक आवाज़ नियंत्रण के लिए WavLM-आधारित 128-डिम स्पीकर प्रतिनिधित्व
* **लगातार 40 सेकंड तक ऑडियो** — लंबे अंशों और संवाद के लिए उपयुक्त
* **रीयल-टाइम या उससे तेज़** — RTX 5080 पर RTF \~0.2, बजट GPU पर भी रीयल-टाइम
* **Apache 2.0** — व्यक्तिगत और व्यावसायिक उपयोग के लिए पूरी तरह खुला
* **प्रीट्रेनिंग फ़्रेमवर्क शामिल** — किसी भी भाषा में शुरुआत से अपना TTS मॉडल प्रशिक्षित करें

## अन्य TTS मॉडलों के साथ तुलना

| मॉडल           | पैरामीटर | न्यूनतम VRAM | वॉइस क्लोनिंग             | भाषा                      | लाइसेंस      |
| -------------- | -------- | ------------ | ------------------------- | ------------------------- | ------------ |
| **Kani-TTS-2** | 400M     | 3GB          | ✅ शून्य-शॉट               | अंग्रेज़ी (विस्तार योग्य) | Apache 2.0   |
| Kokoro         | 82M      | 2GB          | ❌ पूर्व-निर्धारित आवाज़ें | EN, JP, CN                | Apache 2.0   |
| Zonos          | 400M     | 8GB          | ✅                         | मल्टी                     | Apache 2.0   |
| ChatTTS        | 300M     | 4GB          | ❌ यादृच्छिक सीड           | चीनी, अंग्रेज़ी           | AGPL 3.0     |
| Chatterbox     | 500M     | 6GB          | ✅                         | अंग्रेज़ी                 | Apache 2.0   |
| XTTS (Coqui)   | 467M     | 6GB          | ✅                         | मल्टी                     | MPL 2.0      |
| F5-TTS         | 335M     | 4GB          | ✅                         | मल्टी                     | CC-BY-NC 4.0 |

## आवश्यकताएँ

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

| घटक    | न्यूनतम              | अनुशंसित          |
| ------ | -------------------- | ----------------- |
| GPU    | 3GB VRAM वाला कोई भी | RTX 3060 या बेहतर |
| VRAM   | 3GB                  | 6GB               |
| RAM    | 8GB                  | 16GB              |
| डिस्क  | 2GB                  | 5GB               |
| Python | 3.9+                 | 3.11+             |
| CUDA   | 12.8+                | 12.8+             |

**Clore.ai की सिफारिश:** एक RTX 3060 ($0.03–0.07/घंटा) पर्याप्त से भी अधिक है। Clore.ai पर सबसे सस्ते GPU instances भी Kani-TTS-2 को आराम से चलाएँगे। बैच प्रोसेसिंग (ऑडियोबुक, डेटासेट) के लिए, RTX 4090 ($0.14–0.42/घंटा) उत्कृष्ट throughput प्रदान करता है।

## इंस्टॉलेशन

```bash
# पैकेज इंस्टॉल करें
pip install kani-tts-2

# महत्वपूर्ण: संगत transformers संस्करण इंस्टॉल करें (LFM2 आर्किटेक्चर के लिए आवश्यक)
pip install -U "transformers==4.56.0"

# वैकल्पिक: ऑडियो सहेजने के लिए soundfile इंस्टॉल करें
pip install soundfile
```

## त्वरित शुरुआत

भाषण उत्पन्न करने के लिए तीन पंक्तियाँ:

```python
from kani_tts import KaniTTS

# अंग्रेज़ी मॉडल के साथ प्रारंभ करें
model = KaniTTS('nineninesix/kani-tts-2-en')

# भाषण उत्पन्न करें
audio, text = model("नमस्ते! Kani TTS 2, कुशल टेक्स्ट-टू-स्पीच की अगली पीढ़ी में आपका स्वागत है।")

# फ़ाइल में सहेजें
model.save_audio(audio, "output.wav")
```

## उपयोग के उदाहरण

### 1. मूल टेक्स्ट-टू-स्पीच

```python
from kani_tts import KaniTTS

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

# कस्टम पैरामीटर के साथ जनरेट करें
audio, text = model(
    "तेज़ भूरी लोमड़ी आलसी कुत्ते के ऊपर कूदती है। "
    "यह वाक्य अंग्रेज़ी वर्णमाला के हर अक्षर को शामिल करता है।",
    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. वॉइस क्लोनिंग

छोटे संदर्भ ऑडियो सैंपल से किसी भी आवाज़ को क्लोन करें:

```python
from kani_tts import KaniTTS, SpeakerEmbedder

# मॉडलों को प्रारंभ करें
model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# संदर्भ ऑडियो से स्पीकर एम्बेडिंग निकालें (3-30 सेकंड अनुशंसित)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# क्लोन की गई आवाज़ में भाषण जनरेट करें
audio, text = model(
    "यह Kani TTS 2 के साथ वॉइस क्लोनिंग का एक प्रदर्शन है। "
    "आप जो आवाज़ सुन रहे हैं, वह संदर्भ ऑडियो सैंपल से मेल खानी चाहिए।",
    speaker_emb=speaker_embedding
)

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

### 3. ऑडियोबुक के लिए बैच जनरेशन

कई अध्याय कुशलतापूर्वक जनरेट करें:

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

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

# कथावाचक आवाज़ का उपयोग करें
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "अध्याय एक। अप्रैल का एक उजला, ठंडा दिन था, और घड़ियाँ तेरह बजा रही थीं।",
    "अध्याय दो। गलियारे में उबली पत्तागोभी और पुराने चटाइयों की गंध आ रही थी।",
    "अध्याय तीन। बाहर, बंद खिड़की के शीशे के आर-पार भी, दुनिया ठंडी लग रही थी।",
]

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-संगत स्ट्रीमिंग API

रीयल-टाइम अनुप्रयोगों के लिए, OpenAI-संगत सर्वर का उपयोग करें:

```bash
# सर्वर क्लोन करें
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# निर्भरताएँ इंस्टॉल करें
pip install -r requirements.txt

# server शुरू करें
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080
```

फिर इसे किसी भी OpenAI TTS क्लाइंट के साथ उपयोग करें:

```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="OpenAI-संगत Kani TTS सर्वर से नमस्ते!"
)

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

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

1. **इसे चलाने वाला यह सबसे सस्ता मॉडल है** — 3GB VRAM पर, Kani-TTS-2 Clore.ai पर सचमुच किसी भी GPU instance पर चलता है। $0.03–0.07/घंटा वाला RTX 3060 उत्पादन TTS के लिए पर्याप्त से अधिक है।
2. **इसे एक भाषा मॉडल के साथ संयोजित करें** — एक GPU instance किराए पर लें और पूर्ण वॉइस असिस्टेंट के लिए एक छोटे LLM (जैसे, Mistral 3 8B) और Kani-TTS-2 दोनों को एक साथ चलाएँ। वे पर्याप्त खाली जगह के साथ GPU साझा करेंगे।
3. **स्पीकर एम्बेडिंग पहले से गणना करें** — स्पीकर एम्बेडिंग एक बार निकालें और उन्हें सहेज लें। इससे हर अनुरोध पर WavLM एम्बेडर मॉडल लोड करने की आवश्यकता नहीं रहती।
4. **OpenAI-संगत सर्वर का उपयोग करें** — यह `kani-tts-2-openai-server` OpenAI की TTS API के लिए एक ड्रॉप-इन विकल्प प्रदान करता है, जिससे इसे मौजूदा अनुप्रयोगों के साथ एकीकृत करना आसान हो जाता है।
5. **कस्टम भाषाओं पर प्रशिक्षण दें** — Kani-TTS-2 में एक पूर्ण प्रीट्रेनिंग फ़्रेमवर्क शामिल है ([kani-tts-2-pretrain](https://github.com/nineninesix-ai/kani-tts-2-pretrain)). अपने स्वयं के भाषा डेटासेट पर मॉडल को फाइन-ट्यून करें — इसमें लगभग 6 घंटे के लिए केवल 8× H100s लगते हैं।

## समस्या निवारण

| समस्या                                        | समाधान                                                                                                              |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `ImportError: LFM2 को आयात नहीं किया जा सकता` | सही transformers संस्करण इंस्टॉल करें: `pip install -U "transformers==4.56.0"`                                      |
| ऑडियो गुणवत्ता खराब / रोबोट जैसी है           | बढ़ाएँ `temperature` को 0.8–0.9 तक; सुनिश्चित करें कि क्लोनिंग के लिए संदर्भ ऑडियो साफ़ हो (कोई पृष्ठभूमि शोर नहीं) |
| वॉइस क्लोनिंग संदर्भ जैसी नहीं लगती           | 5–15 सेकंड का स्पष्ट, एकल-प्रवक्ता ऑडियो उपयोग करें। संदर्भ में संगीत या पृष्ठभूमि शोर से बचें                      |
| `CUDA out of memory`                          | 3GB मॉडल के साथ ऐसा नहीं होना चाहिए — जाँचें कि क्या अन्य प्रक्रियाएँ GPU मेमोरी का उपयोग कर रही हैं (`nvidia-smi`) |
| ऑडियो वाक्य के बीच में कट जाता है             | Kani-TTS-2 लगभग 40 सेकंड तक सपोर्ट करता है। लंबे पाठ को वाक्यों में विभाजित करें और आउटपुट को जोड़ दें              |
| CPU पर धीमा                                   | GPU इन्फ़रेंस की दृढ़ता से सिफारिश की जाती है। एक बुनियादी GPU भी CPU से 10–50× तेज़ है                             |

## अधिक पढ़ें

* [GitHub — kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) — PyPI पैकेज, उपयोग दस्तावेज़, उन्नत उदाहरण
* [HuggingFace — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — अंग्रेज़ी मॉडल वेट्स
* [प्रीट्रेनिंग फ़्रेमवर्क](https://github.com/nineninesix-ai/kani-tts-2-pretrain) — शुरुआत से अपना TTS मॉडल प्रशिक्षित करें
* [OpenAI-संगत सर्वर](https://github.com/nineninesix-ai/kani-tts-2-openai-server) — OpenAI TTS API के लिए ड्रॉप-इन विकल्प
* [स्पीकर एम्बेडिंग मॉडल](https://huggingface.co/nineninesix/speaker-emb-tbr) — WavLM-आधारित वॉइस एम्बेडर
* [MarkTechPost अवलोकन](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/) — समुदाय कवरेज


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/kani-tts.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.