> 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

Kokoro एक 82M-पैरामीटर टेक्स्ट-टू-स्पीच मॉडल है जो अपने आकार से कहीं बेहतर प्रदर्शन करता है। अपनी छोटी साइज (2 GB VRAM से कम) के बावजूद, यह असाधारण रूप से प्राकृतिक अंग्रेजी भाषण उत्पन्न करता है और सस्ते हार्डवेयर पर भी रीयल‑टाइम या उससे तेज़ गति पर चलता है। Apache 2.0 लाइसेंसिंग, कई बिल्ट‑इन वॉइस स्टाइल और CPU इनफेरेंस सपोर्ट के साथ, 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 पर भी
* **कई वॉइस स्टाइल** — अमेरिकी अंग्रेज़ी, ब्रिटिश अंग्रेज़ी; पुरुष और महिला वॉइसेज़
* **रीयल-टाइम या उससे तेज़** — स्ट्रीमिंग के लिए उपयुक्त कम‑लेटेंसी इनफेरेंस
* **स्ट्रीमिंग जनरेशन** — जैसे-जैसे ऑडियो बनता है उसमेंchunks/खंड देता है
* **बहु-भाषा समर्थन** — अंग्रेजी (मुख्य), जापानी (`misaki[ja]`), चीनी (`misaki[zh]`)
* **Apache 2.0** — व्यक्तिगत और व्यावसायिक उपयोग के लिए मुफ्त

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

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

**Clore.ai सिफारिश:** एक RTX 3060 (\~$0.15–0.30/दिन) अधिक than पर्याप्त है। Kokoro अत्यंत किफायती TTS के लिए CPU‑only इंस्टेंस पर भी चल सकता है।

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

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

# Kokoro और ऑडियो 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 ready')"
```

## त्वरित प्रारम्भ

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

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

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

# ऑडियो जेनरेट करें — वॉइस विकल्प: 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("Done!")
```

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

### कई वॉइसेज़ की तुलना

तुलना करने के लिए एक ही टेक्स्ट विभिन्न वॉइसेज़ के साथ जनरेट करें:

```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}")
```

### स्पीड कंट्रोल के साथ ब्रिटिश इंग्लिश

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

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

text = "Good afternoon. This is a demonstration of British English synthesis."

# 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"Total duration: {len(combined)/24000:.1f}s")
```

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

कई टेक्स्ट प्रोसेस करें और एक सिंगल ऑडियोबुक‑स्टाइल फ़ाइल में जोड़ें:

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

pipeline = KPipeline(lang_code='a')

chapters = [
    "Chapter one. The beginning of our journey starts here.",
    "The sun rose over the mountains, casting long shadows across the valley.",
    "She opened the door and stepped into the unknown.",
]

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

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"Chapter {idx+1} done")

combined = np.concatenate(all_audio)
sf.write('audiobook.wav', combined, 24000)
print(f"Total: {len(combined)/24000:.1f}s")
```

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

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

## समस्याओं का निवारण

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

```
GET https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/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.