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

# TTS इंजन तुलना

Clore.ai GPU सर्वरों पर तैनाती के लिए प्रमुख ओपन-सोर्स टेक्स्ट-टू-स्पीच इंजनों की तुलना करें।

{% hint style="info" %}
**टेक्स्ट-टू-स्पीच (TTS)** लिखित पाठ को प्राकृतिक-सा सुनाई देने वाले ऑडियो में बदलता है। यह गाइड पाँच प्रमुख ओपन-सोर्स TTS इंजनों की तुलना करती है: XTTS v2, Bark, Kokoro, Fish Speech, और MeloTTS — जिसमें गुणवत्ता, गति, भाषा समर्थन, और आवाज़ क्लोनिंग क्षमताएँ शामिल हैं।
{% endhint %}

***

## त्वरित निर्णय मैट्रिक्स

|                    | XTTS v2               | Bark              | Kokoro         | Fish Speech        | MeloTTS        |
| ------------------ | --------------------- | ----------------- | -------------- | ------------------ | -------------- |
| **डेवलपर**         | Coqui AI              | Suno AI           | Hexgrad        | Fish Audio         | MyShell AI     |
| **गुणवत्ता**       | ⭐⭐⭐⭐⭐                 | ⭐⭐⭐⭐              | ⭐⭐⭐⭐           | ⭐⭐⭐⭐⭐              | ⭐⭐⭐            |
| **गति**            | मध्यम                 | धीमा              | **तेज़**       | **तेज़**           | **सबसे तेज़**  |
| **वॉइस क्लोनिंग**  | ✅ (3 सेकंड क्लिप)     | ✅ (आवाज़ प्रीसेट) | ✅ (सीमित)      | ✅ (10 सेकंड क्लिप) | ❌              |
| **भाषाएँ**         | 17                    | 10+               | अंग्रेज़ी      | 8+                 | 8              |
| **न्यूनतम VRAM**   | 4GB                   | 8GB               | **CPU ठीक है** | 4GB                | **CPU ठीक है** |
| **लाइसेंस**        | CPML (गैर-व्यावसायिक) | MIT               | Apache 2.0     | CC BY-NC-SA        | MIT            |
| **GitHub स्टार्स** | 35K+ (Coqui TTS)      | 38K+              | 12K+           | 14K+               | 15K+           |

***

## अवलोकन

### XTTS v2

Coqui का XTTS v2 ओपन-सोर्स आवाज़ क्लोनिंग TTS के लिए स्वर्ण मानक है। यह 3-सेकंड के ऑडियो क्लिप से किसी भी आवाज़ की असाधारण सटीकता के साथ क्लोनिंग कर सकता है।

**दर्शन**: अधिकतम अभिव्यंजकता और आवाज़ क्लोनिंग गुणवत्ता।

```python
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# 3 सेकंड के संदर्भ से ज़ीरो-शॉट आवाज़ क्लोनिंग
tts.tts_to_file(
    text="नमस्ते, यह एक क्लोन की गई आवाज़ है जो स्वाभाविक रूप से बोल रही है।",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Suno का Bark एक ट्रांसफॉर्मर-आधारित TTS मॉडल है जो अत्यधिक अभिव्यंजक भाषण उत्पन्न करता है, जिसमें गैर-भाषण ध्वनियाँ भी शामिल हैं: हँसी, आहें, संगीत, और ध्वनि प्रभाव।

**दर्शन**: सिर्फ भाषण नहीं — पूर्ण ऑडियो जनरेशन।

```python
from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav

preload_models()

audio_array = generate_audio(
    "[हँसते हुए] नमस्ते! [गला साफ़ करते हुए] यह Bark TTS है। [आह भरते हुए]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro एक हल्का, तेज़ TTS मॉडल है जो अंग्रेज़ी के लिए अनुकूलित है। अपने छोटे आकार (\~82M पैरामीटर) के बावजूद, यह आश्चर्यजनक रूप से उच्च गुणवत्ता देता है।

**दर्शन**: छोटा मॉडल, बड़ी गुणवत्ता, कहीं भी चलता है।

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

pipeline = KPipeline(lang_code='a')  # 'a' = अमेरिकी अंग्रेज़ी

generator = pipeline(
    "तेज़ भूरी लोमड़ी आलसी कुत्ते के ऊपर कूदती है।",
    voice='af_heart',  # पूर्व-निर्मित आवाज़
    speed=1.0,
)

for _, _, audio in generator:
    sf.write('output.wav', audio, 24000)
```

### Fish Speech

Fish Audio का Fish Speech एक प्रोडक्शन-ग्रेड TTS है जिसमें छोटे क्लिप्स से असाधारण आवाज़ क्लोनिंग है। यह एक नवीन कोडेक + भाषा मॉडल वास्तुकला का उपयोग करता है।

**दर्शन**: प्रोडक्शन-स्तरीय गुणवत्ता, तेज़ इन्फरेंस, बेहतरीन क्लोनिंग।

```python
# HTTP API के माध्यम से Fish Speech
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "नमस्ते, यह Fish Speech ऑडियो उत्पन्न कर रहा है।",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

with open("output.wav", "wb") as f:
    f.write(response.content)
```

### MeloTTS

MyShell का MeloTTS अत्यंत तेज़, बहु-उच्चारण TTS है जो रीयल-टाइम अनुप्रयोगों के लिए अनुकूलित है। यह CPU पर कुशलता से चलता है और कई अंग्रेज़ी उच्चारणों तथा एशियाई भाषाओं का समर्थन करता है।

**दर्शन**: किसी भी पैमाने पर रीयल-टाइम गति।

```python
from melo.api import TTS

speed = 1.0
device = 'auto'

model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'output.wav'
model.tts_to_file(
    "नमस्ते दुनिया! MeloTTS बहुत तेज़ है।",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)
```

***

## गुणवत्ता तुलना

### स्वाभाविकता स्कोर (MOS — Mean Opinion Score, 1-5)

{% hint style="info" %}
MOS स्कोर प्रकाशित शोधपत्रों और समुदाय मूल्यांकन पर आधारित अनुमानित मान हैं। वास्तविक गुणवत्ता पाठ की सामग्री और आवाज़ कॉन्फ़िगरेशन पर बहुत निर्भर करती है।
{% endhint %}

| मॉडल        | अंग्रेज़ी MOS | बहुभाषी MOS                | अभिव्यंजकता      |
| ----------- | ------------- | -------------------------- | ---------------- |
| XTTS v2     | 4.3           | 4.1                        | ⭐⭐⭐⭐⭐            |
| Bark        | 3.9           | 3.7                        | ⭐⭐⭐⭐⭐ (अद्वितीय) |
| Kokoro      | 4.2           | लागू नहीं (केवल अंग्रेज़ी) | ⭐⭐⭐              |
| Fish Speech | 4.4           | 4.2                        | ⭐⭐⭐⭐             |
| MeloTTS     | 3.8           | 3.6                        | ⭐⭐               |

### हर मॉडल किसमें सर्वश्रेष्ठ है

| मॉडल        | विशेष गुणवत्ता विशेषता                             |
| ----------- | -------------------------------------------------- |
| XTTS v2     | लगभग परिपूर्ण आवाज़ क्लोनिंग, भावनात्मक रेंज       |
| Bark        | गैर-भाषण ध्वनियाँ, हँसी, संगीत, प्रभाव             |
| Kokoro      | गुणवत्ता-से-आकार का सर्वोत्तम अनुपात, प्राकृतिक लय |
| Fish Speech | कुल मिलाकर सर्वोत्तम स्वाभाविकता + क्लोनिंग सटीकता |
| MeloTTS     | लंबे पाठ के लिए सुसंगत, साफ़ आउटपुट                |

***

## गति बेंचमार्क

### प्रति सेकंड वर्ण (CPU बनाम GPU)

परीक्षण: "तेज़ भूरी लोमड़ी आलसी कुत्ते के ऊपर कूदती है। आप आज कैसे हैं?" (60 वर्ण)

| मॉडल        | CPU गति           | GPU गति (RTX 3080) | रियल-टाइम फ़ैक्टर |
| ----------- | ----------------- | ------------------ | ----------------- |
| XTTS v2     | \~15 chars/s      | \~150 chars/s      | 0.3× (GPU)        |
| Bark        | \~5 chars/s       | \~40 chars/s       | 0.1× (GPU)        |
| Kokoro      | \~200 chars/s     | \~800 chars/s      | **5× (GPU)**      |
| Fish Speech | \~80 chars/s      | \~500 chars/s      | **3× (GPU)**      |
| MeloTTS     | **\~500 chars/s** | \~2000 chars/s     | **12× (GPU)**     |

*रीयल-टाइम फ़ैक्टर > 1.0 का मतलब है प्लेबैक गति से तेज़*

### 1 मिनट ऑडियो उत्पन्न करने का समय

| मॉडल        | CPU          | RTX 3080   | A100       |
| ----------- | ------------ | ---------- | ---------- |
| XTTS v2     | \~8 मिनट     | \~30 सेकंड | \~10 सेकंड |
| Bark        | लगभग 20 मिनट | \~3 मिनट   | \~45 सेकंड |
| Kokoro      | \~20 सेकंड   | \~5 सेकंड  | \~2s       |
| Fish Speech | \~45 सेकंड   | \~8s       | \~3s       |
| MeloTTS     | **\~8s**     | **\~2s**   | **<1s**    |

{% hint style="success" %}
**रीयल-टाइम अनुप्रयोगों के लिए**: MeloTTS और Kokoro स्पष्ट विजेता हैं। दोनों CPU पर भी प्लेबैक गति से तेज़ भाषण उत्पन्न कर सकते हैं।
{% endhint %}

***

## भाषा समर्थन

### समर्थित भाषाएँ

| मॉडल        | भाषाएँ | विशेष                                                              |
| ----------- | ------ | ------------------------------------------------------------------ |
| XTTS v2     | 17     | EN, ES, FR, DE, IT, PT, PL, TR, RU, NL, CS, AR, ZH, JA, HU, KO, HI |
| Bark        | 10+    | EN, ZH, FR, DE, HI, IT, JA, KO, PL, PT, RU, ES, TR                 |
| Kokoro      | 2      | अंग्रेज़ी (US/UK), जापानी (सीमित)                                  |
| Fish Speech | 8      | EN, ZH, JA, KO, FR, DE, AR, ES                                     |
| MeloTTS     | 8      | EN (4 उच्चारण), ES, FR, ZH, JA, KO                                 |

### भाषा गुणवत्ता नोट्स

| मॉडल        | अंग्रेज़ी | चीनी          | जापानी  | यूरोपीय  |
| ----------- | --------- | ------------- | ------- | -------- |
| XTTS v2     | उत्कृष्ट  | अच्छा         | अच्छा   | उत्कृष्ट |
| Bark        | अच्छा     | ठीक-ठाक       | ठीक-ठाक | अच्छा    |
| Kokoro      | उत्कृष्ट  | ❌             | सीमित   | ❌        |
| Fish Speech | उत्कृष्ट  | **सर्वोत्तम** | अच्छा   | अच्छा    |
| MeloTTS     | अच्छा     | अच्छा         | अच्छा   | अच्छा    |

{% hint style="info" %}
**चीनी TTS के लिए**: Fish Speech और MeloTTS सबसे अच्छे ओपन-सोर्स विकल्प हैं। दोनों स्वरों और वर्णों को स्वाभाविक रूप से संभालते हैं।

**बहुभाषी अनुप्रयोगों के लिए**: XTTS v2 सबसे अधिक भाषाओं का समर्थन करता है, और सभी में समान गुणवत्ता देता है।
{% endhint %}

***

## आवाज़ क्लोनिंग तुलना

### क्लोनिंग क्षमताएँ

| मॉडल        | संदर्भ लंबाई       | क्लोनिंग गुणवत्ता | ज़ीरो-शॉट |
| ----------- | ------------------ | ----------------- | --------- |
| XTTS v2     | **3 सेकंड**        | ⭐⭐⭐⭐⭐             | ✅         |
| Bark        | केवल आवाज़ प्रीसेट | ⭐⭐⭐               | आंशिक     |
| Kokoro      | समर्थित नहीं       | ❌                 | ❌         |
| Fish Speech | 10 सेकंड           | ⭐⭐⭐⭐⭐             | ✅         |
| MeloTTS     | समर्थित नहीं       | ❌                 | ❌         |

### XTTS v2 आवाज़ क्लोनिंग

```python
from TTS.api import TTS
import torch

# मॉडल लोड करें
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.to("cuda" if torch.cuda.is_available() else "cpu")

# संदर्भ से आवाज़ क्लोन करें (न्यूनतम 3 सेकंड, आदर्श 10-30 सेकंड)
tts.tts_to_file(
    text="""
    हमारे पॉडकास्ट में आपका स्वागत है। आज हम AI के भविष्य पर चर्चा कर रहे हैं 
    और समाज पर इसके प्रभाव पर। मैं आपका होस्ट हूँ, और मैं उत्साहित हूँ 
    आपके साथ कुछ रोचक जानकारियाँ साझा करने के लिए।
    """,
    speaker_wav="speaker_sample.wav",  # आपका संदर्भ ऑडियो
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Fish Speech आवाज़ क्लोनिंग

```bash
# संदर्भ ऑडियो से क्लोन करें
fish_speech_cli tts \\
  --text "यह मेरी क्लोन की गई आवाज़ है जो एक नया वाक्य बोल रही है।" \\
  --reference-audio speaker_sample.wav \\
  --reference-text "संदर्भ ऑडियो में बोला गया मूल पाठ।" \\
  --output cloned_output.wav
```

### Bark आवाज़ प्रीसेट

```python
from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Bark पूर्वनिर्धारित स्पीकर कोड का उपयोग करता है
voice_presets = {
    "male_US": "v2/en_speaker_6",
    "female_US": "v2/en_speaker_9",
    "male_UK": "v2/en_speaker_0",
    "announcer": "v2/en_speaker_2",
}

audio = generate_audio(
    "स्वागत है! [हँसते हुए] यह बिल्कुल अद्भुत तकनीक है।"
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2: गहन विश्लेषण

### आर्किटेक्चर

* **VITS + GPT** संकर वास्तुकला
* 17 भाषाओं में 16K+ घंटों के डेटा पर प्रशिक्षित
* ज़ीरो-शॉट क्लोनिंग के लिए 3 सेकंड न्यूनतम

### Clore.ai पर स्थापना

```bash
pip install TTS
# GPU संस्करण
pip install TTS[all]
```

### Docker परिनियोजन

```dockerfile
FROM nvidia/cuda:12.8.1-cudnn-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y python3 python3-pip git ffmpeg
RUN pip3 install TTS fastapi uvicorn

WORKDIR /app
COPY server.py .

EXPOSE 5002
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "5002"]
```

```python
# server.py — XTTS v2 REST API
from fastapi import FastAPI, UploadFile, Form
from fastapi.responses import FileResponse
from TTS.api import TTS
import tempfile, os

app = FastAPI()
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

@app.post("/tts")
async def synthesize(
    text: str = Form(...),
    language: str = Form("en"),
    speaker_file: UploadFile = None
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out:
        output_path = out.name

    speaker_path = None
    if speaker_file:
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref:
            ref.write(await speaker_file.read())
            speaker_path = ref.name

    tts.tts_to_file(
        text=text,
        speaker_wav=speaker_path,
        language=language,
        file_path=output_path
    )
    return FileResponse(output_path, media_type="audio/wav")
```

```bash
docker build -t xtts-server .
docker run -d --gpus all -p 5002:5002 xtts-server
```

**कमज़ोरियाँ**: CPML लाइसेंस (अनुमति के बिना गैर-व्यावसायिक उपयोग), Kokoro/MeloTTS से धीमा

***

## Bark: गहन विश्लेषण

### आर्किटेक्चर

* **GPT-शैली ट्रांसफॉर्मर** ऑडियो टोकन जनरेशन के लिए
* तीन-चरण प्रक्रिया: पाठ → अर्थगत → मोटे → सूक्ष्म टोकन
* वास्तविक ऑडियो कोडेक टोकन (EnCodec) उत्पन्न करता है

### Bark को विशिष्ट क्या बनाता है

Bark एकमात्र ओपन-सोर्स TTS है जो मूल रूप से उत्पन्न करता है:

* 🎵 भाषण के भीतर पृष्ठभूमि संगीत
* 😂 हँसी, आहें, गला साफ़ करना
* 🎭 एक ही जनरेशन में कई वक्ता
* 🌍 मिश्रित-भाषा उच्चारण

### मार्कअप भाषा

```python
from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# अभिव्यक्तिशीलता के लिए विशेष टोकन
text = """
[गला साफ़ करते हुए] सुप्रभात सभी को। [हँसते हुए] 
आज की प्रस्तुति में शामिल होगा... 
[गहरी आह भरते हुए] ...वास्तव में काफी कुछ।
[संगीत: उत्साही जैज़] चलिए शुरू करते हैं!
"""

audio = generate_audio(text, history_prompt="v2/en_speaker_6")
write("output.wav", SAMPLE_RATE, audio)
```

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

```bash
pip install git+https://github.com/suno-ai/bark.git
```

**कमज़ोरियाँ**: धीमा (3-चरणीय पाइपलाइन), रन के बीच असंगत, सच्ची आवाज़ क्लोनिंग नहीं

***

## Kokoro: गहन विश्लेषण

### आर्किटेक्चर

* **82M पैरामीटर** StyleTTS2-आधारित मॉडल
* बहुत छोटा लेकिन आश्चर्यजनक रूप से उच्च गुणवत्ता वाला
* CPU और GPU पर तेज़ इन्फरेंस

### उपलब्ध आवाज़ें

```python
from kokoro import KPipeline

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

# उपलब्ध आवाज़ें
voices = {
    'af_heart': 'अमेरिकी महिला (गर्मजोशीपूर्ण)',
    'af_bella': 'अमेरिकी महिला (bella)',
    'af_nicole': 'अमेरिकी महिला (nicole)',
    'am_michael': 'अमेरिकी पुरुष (michael)',
    'am_fenrir': 'अमेरिकी पुरुष (fenrir)',
    'bf_emma': 'ब्रिटिश महिला (emma)',
    'bm_george': 'ब्रिटिश पुरुष (george)',
}

# अलग-अलग आवाज़ों के साथ जनरेट करें
for voice_name, description in voices.items():
    gen = pipeline("नमस्ते, यह एक परीक्षण है।", voice=voice_name)
    for _, _, audio in gen:
        print(f"{description} के साथ जनरेट किया गया")
```

### स्ट्रीमिंग समर्थन

```python
import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# जैसे-जैसे ऑडियो बनता है, उसे रीयल-टाइम में स्ट्रीम करें
text = "यह एक बहुत लंबा पाठ है जिसे जनरेशन के साथ-साथ स्ट्रीम किया जाएगा, जिससे कम-विलंबता ऑडियो आउटपुट मिलेगा।"

for _, _, audio in pipeline(text, voice='af_heart'):
    sd.play(audio, samplerate=24000)
    sd.wait()
```

**कमज़ोरियाँ**: मुख्यतः केवल अंग्रेज़ी, आवाज़ क्लोनिंग नहीं, सीमित अभिव्यक्तिशीलता

***

## Fish Speech: गहन विश्लेषण

### आर्किटेक्चर

* **VQGAN + भाषा मॉडल** वास्तुकला
* 700K+ घंटों के ऑडियो पर प्रशिक्षित
* एशियाई भाषा समर्थन के साथ मजबूत बहुभाषी

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

```bash
pip install fish-speech

# या Docker के माध्यम से
docker run -d \\
  --gpus all \\
  -p 8080:8080 \
  fishaudio/fish-speech:latest \\
  +api_server.workers_count=1
```

### Python API

```python
import httpx
import base64

# HTTP API के माध्यम से
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "नमस्ते Fish Speech से! यह बहुत स्वाभाविक लगता है।",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)
```

### वॉइस क्लोनिंग

```python
# संदर्भ अपलोड करें, वापस आवाज़ ID प्राप्त करें
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "इस रिकॉर्डिंग में बोला गया पाठ।"}
    )
    voice_id = response.json()["id"]

# क्लोन की गई आवाज़ का उपयोग करें
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "अब क्लोन की गई आवाज़ में बोल रहा हूँ।",
        "reference_id": voice_id,
    }
)
```

**कमज़ोरियाँ**: CC BY-NC-SA लाइसेंस (गैर-व्यावसायिक), सर्वोत्तम गुणवत्ता के लिए अधिक VRAM

***

## MeloTTS: गहन विश्लेषण

### आर्किटेक्चर

* **VITS2-आधारित** वास्तुकला
* बहु-उच्चारण अंग्रेज़ी प्रशिक्षण
* इन्फरेंस गति के लिए अत्यधिक अनुकूलित

### उच्चारण और भाषाएँ

```python
from melo.api import TTS

# समर्थित भाषा कोड और उच्चारण
configs = {
    'EN':    ['EN-Default', 'EN-US', 'EN-BR', 'EN-INDIA', 'EN-AU'],
    'ES':    ['ES'],
    'FR':    ['FR'],
    'ZH':    ['ZH'],
    'JP':    ['JP'],
    'KR':    ['KR'],
}

model = TTS(language='EN', device='cuda')
speaker_ids = model.hps.data.spk2id

# ब्रिटिश उच्चारण के साथ जनरेट करें
model.tts_to_file(
    "नमस्कार! क्या चाय की एक प्याली पसंद करेंगे?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# भारतीय उच्चारण के साथ जनरेट करें
model.tts_to_file(
    "नमस्ते! हमारी कंपनी में आपका स्वागत है।",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### बैच प्रोसेसिंग (बहुत तेज़)

```python
from melo.api import TTS
import time

model = TTS(language='EN', device='cuda')
sid = model.hps.data.spk2id['EN-Default']

texts = [
    "संश्लेषित करने के लिए पहला वाक्य।",
    "दूसरा वाक्य यहाँ है।",
    "तीसरा और अंतिम वाक्य।",
]

start = time.time()
for i, text in enumerate(texts):
    model.tts_to_file(text, sid, f'output_{i}.wav')
elapsed = time.time() - start
print(f"{elapsed:.2f}s में {len(texts)} फ़ाइलें जनरेट की गईं")
```

**कमज़ोरियाँ**: कोई वॉइस क्लोनिंग नहीं, उच्च गति पर रोबोटिक, सीमित अभिव्यक्तिशीलता

***

## Clore.ai पर परिनियोजन

### सभी-इन-वन TTS सर्वर

```yaml
# docker-compose.yml — कई बैकएंड्स वाला TTS सेवा
version: "3.8"

services:
  xtts:
    build:
      context: ./xtts
    ports:
      - "5002:5002"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    volumes:
      - ./voices:/app/voices

  kokoro:
    image: ghcr.io/remsky/kokoro-fastapi-cpu:latest
    ports:
      - "8880:8880"
    # GPU की आवश्यकता नहीं!

  fish-speech:
    image: fishaudio/fish-speech:latest
    ports:
      - "8080:8080"
    command: +api_server.workers_count=2
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

### VRAM आवश्यकताओं का सारांश

| मॉडल        | CPU           | 4GB GPU | 8GB GPU | 16GB GPU |
| ----------- | ------------- | ------- | ------- | -------- |
| XTTS v2     | धीमा          | ✅       | ✅       | ✅        |
| Bark        | बहुत धीमा     | ❌       | ✅       | ✅        |
| Kokoro      | **तेज़**      | ✅       | ✅       | ✅        |
| Fish Speech | मध्यम         | ✅       | ✅       | ✅        |
| MeloTTS     | **बहुत तेज़** | ✅       | ✅       | ✅        |

***

## एकीकरण के उदाहरण

### OpenAI-संगत API (ड्रॉप-इन प्रतिस्थापन के लिए)

```python
# कई TTS सर्वर OpenAI-संगत एंडपॉइंट्स प्रदान करते हैं
# Kokoro FastAPI या समान का उपयोग करें

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # आपका TTS सर्वर
    api_key="not-needed"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hello world! यह OpenAI TTS API प्रारूप का उपयोग करता है.",
)
response.stream_to_file("output.mp3")
```

### LangChain एकीकरण

```python
# वॉइस एजेंट्स के लिए LangChain के साथ TTS का उपयोग
from langchain_community.tools import Tool
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

def speak(text: str) -> str:
    tts.tts_to_file(text=text, language="en", file_path="/tmp/response.wav")
    return "/tmp/response.wav"

tts_tool = Tool(
    name="text_to_speech",
    func=speak,
    description="टेक्स्ट को स्पीच ऑडियो फ़ाइल में बदलें"
)
```

***

## किसका उपयोग कब करें

### निर्णय मार्गदर्शिका

```
छोटे क्लिप से वॉइस क्लोनिंग चाहिए?
  → XTTS v2 (3s संदर्भ) या Fish Speech (10s संदर्भ)

रियल-टाइम/सबसे तेज़ जनरेशन चाहिए?
  → MeloTTS (CPU के अनुकूल) या Kokoro

अभिव्यंजक स्पीच चाहिए (हँसी, भावना)?
  → Bark (विशिष्ट गैर-स्पीच ध्वनियाँ) या XTTS v2

चीनी/जापानी/कोरियाई चाहिए?
  → Fish Speech (CJK के लिए सर्वोत्तम) या MeloTTS

केवल अंग्रेज़ी, अधिकतम गुणवत्ता?
  → Kokoro (आकार/गुणवत्ता अनुपात में सर्वश्रेष्ठ)

17+ भाषाएँ चाहिए?
  → XTTS v2

वाणिज्यिक उपयोग की अनुमति है?
  → Kokoro (Apache) या MeloTTS (MIT) या Bark (MIT)

गैर-वाणिज्यिक शोध?
  → कोई भी (XTTS v2 CPML या Fish Speech CC BY-NC-SA)
```

### अनुप्रयोग प्रकार के अनुसार

| अनुप्रयोग           | सर्वोत्तम विकल्प       | क्यों                         |
| ------------------- | ---------------------- | ----------------------------- |
| ऑडियोबुक जनरेशन     | XTTS v2                | स्वाभाविक, सुसंगत आवाज़       |
| रियल-टाइम चैटबॉट    | MeloTTS या Kokoro      | सबसे तेज़ इन्फ़रेंस           |
| पॉडकास्ट ऑटोमेशन    | XTTS v2 या Fish Speech | सर्वश्रेष्ठ क्लोनिंग          |
| गेम कैरेक्टर्स      | Bark                   | अभिव्यंजक, विविध आवाज़ें      |
| ग्राहक सेवा         | MeloTTS                | स्केलेबल, तेज़                |
| एक्सेसिबिलिटी टूल्स | Kokoro                 | हल्का, मुफ़्त                 |
| वॉइस डबिंग          | Fish Speech            | सर्वश्रेष्ठ क्लोनिंग गुणवत्ता |
| दीर्घ-रूप नैरेशन    | XTTS v2                | सुसंगत गुणवत्ता               |

***

## लाइसेंस सारांश

{% hint style="warning" %}
**वाणिज्यिक उपयोग के लिए लाइसेंस महत्वपूर्ण है!** प्रोडक्शन में तैनात करने से पहले हमेशा जाँचें।
{% endhint %}

| मॉडल        | लाइसेंस                   | वाणिज्यिक? | नोट्स                                    |
| ----------- | ------------------------- | ---------- | ---------------------------------------- |
| XTTS v2     | Coqui पब्लिक मॉडल लाइसेंस | ❌ मुफ़्त   | वाणिज्यिक उपयोग के लिए लाइसेंस आवश्यक है |
| Bark        | MIT                       | ✅          | सभी उपयोग के लिए मुफ़्त                  |
| Kokoro      | Apache 2.0                | ✅          | सभी उपयोग के लिए मुफ़्त                  |
| Fish Speech | CC BY-NC-SA 4.0           | ❌          | केवल गैर-वाणिज्यिक                       |
| MeloTTS     | MIT                       | ✅          | सभी उपयोग के लिए मुफ़्त                  |

**वाणिज्यिक उपयोग के लिए पूरी तरह खुला**: Bark, Kokoro, MeloTTS

***

## Clore.ai पर लागत

```
Kokoro/MeloTTS (CPU या सस्ता GPU):
  सबसे सस्ता सर्वर लगभग ~$0.05/घंटा → लगभग ~$36/माह
  CPU पर 100+ समकालिक अनुरोध संभाल सकता है

XTTS v2 (RTX 3080):
  लगभग ~$0.30/घंटा → लगभग ~$220/माह
  लगभग ~500 अनुरोध/घंटा क्षमता

Fish Speech (RTX 4090):
  लगभग ~$0.60/घंटा → लगभग ~$440/माह  
  लगभग ~1000 अनुरोध/घंटा क्षमता
```

***

## उपयोगी लिंक

* [Coqui TTS (XTTS)](https://github.com/coqui-ai/TTS) — 35K+ स्टार्स
* [Bark GitHub](https://github.com/suno-ai/bark) — 38K+ स्टार्स
* [Kokoro GitHub](https://github.com/hexgrad/kokoro) — 12K+ स्टार्स
* [Fish Speech GitHub](https://github.com/fishaudio/fish-speech) — 14K+ स्टार्स
* [MeloTTS GitHub](https://github.com/myshell-ai/MeloTTS) — 15K+ स्टार्स
* [TTS Arena लीडरबोर्ड](https://huggingface.co/spaces/TTS-AGI/TTS-Arena)

***

## सारांश

| मॉडल            | कब उपयोग करें                                                   |
| --------------- | --------------------------------------------------------------- |
| **XTTS v2**     | सर्वश्रेष्ठ वॉइस क्लोनिंग (3s संदर्भ), 17 भाषाएँ, गैर-वाणिज्यिक |
| **Bark**        | अभिव्यंजक, हँसी/प्रभाव, MIT लाइसेंस                             |
| **Kokoro**      | तेज़, उच्च-गुणवत्ता वाली अंग्रेज़ी, Apache लाइसेंस              |
| **Fish Speech** | सर्वश्रेष्ठ CJK, प्रोडक्शन क्लोनिंग, गैर-वाणिज्यिक              |
| **MeloTTS**     | सबसे तेज़, रियल-टाइम, बहु-उच्चारण अंग्रेज़ी, MIT लाइसेंस        |

अधिकांश प्रोडक्शन Clore.ai तैनाती के लिए:

* **रियल-टाइम वॉइस ऐप्स** → MeloTTS या Kokoro (मुफ़्त, तेज़, MIT)
* **वॉइस क्लोनिंग सेवा** → XTTS v2 या Fish Speech (लाइसेंसिंग जाँचें)
* **अभिव्यंजक नैरेशन** → Bark या XTTS v2

***

## Clore.ai GPU अनुशंसाएँ

| उपयोग-प्रकरण   | अनुशंसित GPU    | Clore.ai पर अनुमानित लागत                 |
| -------------- | --------------- | ----------------------------------------- |
| विकास/परीक्षण  | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| प्रोडक्शन      | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| बड़े पैमाने पर | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

> 💡 इस गाइड के सभी उदाहरण [Clore.ai](https://clore.ai/marketplace) GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.


---

# 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/comparisons/tts-comparison.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.