TTS इंजन तुलना

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

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

---

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

	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-सेकंड के ऑडियो क्लिप से किसी भी आवाज़ की असाधारण सटीकता के साथ क्लोनिंग कर सकता है।

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

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 मॉडल है जो अत्यधिक अभिव्यंजक भाषण उत्पन्न करता है, जिसमें गैर-भाषण ध्वनियाँ भी शामिल हैं: हँसी, आहें, संगीत, और ध्वनि प्रभाव।

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

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 पैरामीटर) के बावजूद, यह आश्चर्यजनक रूप से उच्च गुणवत्ता देता है।

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

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 है जिसमें छोटे क्लिप्स से असाधारण आवाज़ क्लोनिंग है। यह एक नवीन कोडेक + भाषा मॉडल वास्तुकला का उपयोग करता है।

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

# 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 पर कुशलता से चलता है और कई अंग्रेज़ी उच्चारणों तथा एशियाई भाषाओं का समर्थन करता है।

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

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)

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

मॉडल	अंग्रेज़ी 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

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

---

भाषा समर्थन

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

मॉडल	भाषाएँ	विशेष
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	अच्छा	अच्छा	अच्छा	अच्छा

चीनी TTS के लिए: Fish Speech और MeloTTS सबसे अच्छे ओपन-सोर्स विकल्प हैं। दोनों स्वरों और वर्णों को स्वाभाविक रूप से संभालते हैं।

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

---

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

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

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

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

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 आवाज़ क्लोनिंग

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

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

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 पर स्थापना

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

Docker परिनियोजन

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"]

# 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")

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

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

---

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

आर्किटेक्चर

• GPT-शैली ट्रांसफॉर्मर ऑडियो टोकन जनरेशन के लिए

• तीन-चरण प्रक्रिया: पाठ → अर्थगत → मोटे → सूक्ष्म टोकन

• वास्तविक ऑडियो कोडेक टोकन (EnCodec) उत्पन्न करता है

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

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

• 🎵 भाषण के भीतर पृष्ठभूमि संगीत

• 😂 हँसी, आहें, गला साफ़ करना

• 🎭 एक ही जनरेशन में कई वक्ता

• 🌍 मिश्रित-भाषा उच्चारण

मार्कअप भाषा

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)

इंस्टॉलेशन

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

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

---

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

आर्किटेक्चर

• 82M पैरामीटर StyleTTS2-आधारित मॉडल

• बहुत छोटा लेकिन आश्चर्यजनक रूप से उच्च गुणवत्ता वाला

• CPU और GPU पर तेज़ इन्फरेंस

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

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} के साथ जनरेट किया गया")

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

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+ घंटों के ऑडियो पर प्रशिक्षित

• एशियाई भाषा समर्थन के साथ मजबूत बहुभाषी

इंस्टॉलेशन

pip install fish-speech

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

Python API

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)

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

# संदर्भ अपलोड करें, वापस आवाज़ 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-आधारित वास्तुकला

• बहु-उच्चारण अंग्रेज़ी प्रशिक्षण

• इन्फरेंस गति के लिए अत्यधिक अनुकूलित

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

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'
)

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

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 सर्वर

# 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 (ड्रॉप-इन प्रतिस्थापन के लिए)

# कई 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 एकीकरण

# वॉइस एजेंट्स के लिए 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	सुसंगत गुणवत्ता

---

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

वाणिज्यिक उपयोग के लिए लाइसेंस महत्वपूर्ण है! प्रोडक्शन में तैनात करने से पहले हमेशा जाँचें।

मॉडल	लाइसेंस	वाणिज्यिक?	नोट्स
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) — 35K+ स्टार्स

• Bark GitHub — 38K+ स्टार्स

• Kokoro GitHub — 12K+ स्टार्स

• Fish Speech GitHub — 14K+ स्टार्स

• MeloTTS GitHub — 15K+ स्टार्स

• 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

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