> 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/kokoro-tts.md).

# Kokoro TTS

Clore.ai GPUs पर Kokoro TTS चलाएँ — एक अल्ट्रा-लाइटवेट 82M-पैरामीटर टेक्स्ट-टू-स्पीच मॉडल।

Kokoro एक 82M-पैरामीटर वाला text-to-speech मॉडल है जो अपनी श्रेणी से कहीं आगे निकलता है। अपने बेहद छोटे आकार (2 GB VRAM से कम) के बावजूद, यह आश्चर्यजनक रूप से स्वाभाविक अंग्रेज़ी भाषण उत्पन्न करता है और बजट हार्डवेयर पर भी रियल-टाइम या उससे तेज़ गति से चलता है। Apache 2.0 लाइसेंसिंग, कई अंतर्निहित आवाज़ शैलियों, और CPU inference समर्थन के साथ, Kokoro रियल-टाइम अनुप्रयोगों, चैटबॉट्स, और एज परिनियोजन के लिए आदर्श है।

**HuggingFace:** [hexgrad/Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) **PyPI:** [kokoro](https://pypi.org/project/kokoro/) **लाइसेंस:** Apache 2.0

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

* **82M पैरामीटर** — उपलब्ध सबसे छोटे उच्च-गुणवत्ता वाले TTS मॉडलों में से एक
* **< 2 GB VRAM** — लगभग किसी भी GPU पर, और यहाँ तक कि CPU पर भी चलता है
* **कई आवाज़ शैलियाँ** — अमेरिकी अंग्रेज़ी, ब्रिटिश अंग्रेज़ी; पुरुष और महिला आवाज़ें
* **रीयल-टाइम या उससे तेज़** — स्ट्रीमिंग के लिए उपयुक्त कम-विलंबता inference
* **स्ट्रीमिंग जनरेशन** — जैसे-जैसे ऑडियो खंड बनते हैं, उन्हें आउटपुट करता है
* **बहु-भाषा समर्थन** — अंग्रेज़ी (प्राथमिक), जापानी (`misaki[ja]`), चीनी (`misaki[zh]`)
* **Apache 2.0** — व्यक्तिगत और व्यावसायिक उपयोग के लिए निःशुल्क

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

| घटक    | न्यूनतम               | अनुशंसित |
| ------ | --------------------- | -------- |
| GPU    | 2 GB VRAM वाला कोई भी | RTX 3060 |
| VRAM   | 2 जीबी                | 4 GB     |
| RAM    | 4 GB                  | 8 GB     |
| डिस्क  | 500 MB                | 1 जीबी   |
| Python | 3.9+                  | 3.11     |
| सिस्टम | espeak-ng स्थापित     | —        |

**Clore.ai की सिफारिश:** एक RTX 3060 ($0.03–0.07/घंटा) पूरी तरह पर्याप्त है। Kokoro CPU-only इंस्टेंस पर भी चल सकता है, जिससे यह बेहद किफ़ायती TTS बनता है।

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

```bash
# सिस्टम निर्भरता इंस्टॉल करें
apt-get install -y espeak-ng

# Kokoro और audio I/O इंस्टॉल करें
pip install kokoro>=0.9.4 soundfile torch

# जापानी समर्थन के लिए (वैकल्पिक)
pip install misaki[ja]

# चीनी समर्थन के लिए (वैकल्पिक)
pip install misaki[zh]

# सत्यापित करें
python -c "from kokoro import KPipeline; print('Kokoro तैयार है')"
```

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

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

# पाइपलाइन आरंभ करें
# 'a' = अमेरिकी अंग्रेज़ी, 'b' = ब्रिटिश अंग्रेज़ी
pipeline = KPipeline(lang_code='a')

text = """
Kokoro एक हल्का text-to-speech मॉडल है, जिसमें केवल बयासी मिलियन
पैरामीटर हैं। अपने छोटे आकार के बावजूद, यह स्वाभाविक और अभिव्यक्तिपूर्ण भाषण उत्पन्न करता है।
"""

# ऑडियो जनरेट करें — voice विकल्प: 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"खंड {i}: {graphemes[:50]}...")

print("पूरा हुआ!")
```

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

### कई आवाज़ों की तुलना

तुलना के लिए एक ही पाठ को अलग-अलग आवाज़ों के साथ जनरेट करें:

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

pipeline = KPipeline(lang_code='a')

text = "Clore.ai में आपका स्वागत है, जो 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"उत्पन्न: {voice}")
```

### गति नियंत्रण के साथ ब्रिटिश अंग्रेज़ी

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

# 'b' = ब्रिटिश अंग्रेज़ी
pipeline = KPipeline(lang_code='b')

text = "शुभ अपराह्न। यह ब्रिटिश अंग्रेज़ी संश्लेषण का एक प्रदर्शन है।"

# speed < 1.0 = धीमा, speed > 1.0 = तेज़
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"कुल अवधि: {len(combined)/24000:.1f} सेकंड")
```

### बैच फ़ाइल प्रोसेसिंग

कई पाठों को प्रोसेस करें और उन्हें एकल ऑडियोबुक-शैली की फ़ाइल में संयोजित करें:

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

pipeline = KPipeline(lang_code='a')

chapters = [
    "अध्याय एक। हमारी यात्रा की शुरुआत यहीं से होती है।",
    "सूरज पहाड़ों के ऊपर उगा, और घाटी पर लंबी परछाइयाँ पड़ गईं।",
    "उसने दरवाज़ा खोला और अनजाने में कदम रखा।",
]

all_audio = []
silence = np.zeros(int(24000 * 0.5))  # अध्यायों के बीच 0.5 सेकंड का मौन

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"अध्याय {idx+1} पूरा हुआ")

combined = np.concatenate(all_audio)
sf.write('audiobook.wav', combined, 24000)
print(f"कुल: {len(combined)/24000:.1f} सेकंड")
```

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

* **CPU inference** — Kokoro इतना छोटा है कि CPU पर चल सकता है; लागत-संवेदनशील कार्यभारों या जब GPU उपलब्ध न हों, तब उपयोगी
* **स्ट्रीमिंग** — जनरेटर जैसे-जैसे ऑडियो खंड बनाता है, उन्हें आउटपुट करता है, जिससे वेब ऐप्स में वास्तविक-समय प्लेबैक संभव होता है
* **WhisperX के साथ संयोजित करें** — वॉइस पाइपलाइनों में ट्रांसक्रिप्शन के लिए WhisperX और पुनः-संश्लेषण के लिए Kokoro का उपयोग करें
* **Docker** — उपयोग करें `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime` और जोड़ें `apt-get install -y espeak-ng` अपने स्टार्टअप के लिए
* **आवाज़ की स्थिरता** — एक सुसंगत नैरेटर अनुभव के लिए प्रति प्रोजेक्ट एक ही voice ID पर टिके रहें
* **लागत दक्षता** — RTX 3060 पर $0.03–0.07/घंटा की दर से, Kokoro self-host करने के लिए सबसे सस्ते TTS समाधानों में से एक है

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

| समस्या                        | समाधान                                                                                      |
| ----------------------------- | ------------------------------------------------------------------------------------------- |
| `espeak-ng नहीं मिला`         | चलाएँ `apt-get install -y espeak-ng` (आवश्यक सिस्टम निर्भरता)                               |
| `ModuleNotFoundError: kokoro` | इसके साथ इंस्टॉल करें `pip install kokoro>=0.9.4 soundfile`                                 |
| ऑडियो रोबोटिक सुनाई देता है   | कोई अलग voice आज़माएँ (जैसे, `af_heart` सबसे स्वाभाविक सुनाई देती है)                       |
| जापानी/चीनी काम नहीं कर रहे   | भाषा extras इंस्टॉल करें: `pip install misaki[ja]` या `misaki[zh]`                          |
| CPU पर मेमोरी समाप्त          | प्रति कॉल पाठ की लंबाई कम करें; Kokoro खंडों को स्ट्रीम करता है, इसलिए मेमोरी सीमित रहती है |
| धीमी पहली रन                  | मॉडल weights पहली बार उपयोग पर डाउनलोड होते हैं (\~200 MB); बाद के रन तुरंत होते हैं        |


---

# 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-hi/audio-and-voice/kokoro-tts.md?ask=<question>&goal=<endgoal>
```

`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.