# Comparación de motores TTS

Compara los principales motores de texto a voz de código abierto para desplegar en servidores GPU de Clore.ai.

{% hint style="info" %}
**Texto a voz (TTS)** convierte texto escrito en audio de sonido natural. Esta guía compara cinco motores TTS de código abierto líderes: XTTS v2, Bark, Kokoro, Fish Speech y MeloTTS — cubriendo calidad, velocidad, soporte de idiomas y capacidades de clonación de voz.
{% endhint %}

***

## Matriz de decisión rápida

|                         | XTTS v2             | Bark                  | Kokoro       | Fish Speech      | MeloTTS           |
| ----------------------- | ------------------- | --------------------- | ------------ | ---------------- | ----------------- |
| **Desarrollador**       | Coqui AI            | Suno AI               | Hexgrad      | Fish Audio       | MyShell AI        |
| **Calidad**             | ⭐⭐⭐⭐⭐               | ⭐⭐⭐⭐                  | ⭐⭐⭐⭐         | ⭐⭐⭐⭐⭐            | ⭐⭐⭐               |
| **Velocidad**           | Medio               | Lento                 | **Rápido**   | **Rápido**       | **El más rápido** |
| **Clonación de voz**    | ✅ (clip de 3 s)     | ✅ (preajustes de voz) | ✅ (limitado) | ✅ (clip de 10 s) | ❌                 |
| **Idiomas**             | 17                  | 10+                   | Inglés       | 8+               | 8                 |
| **VRAM mínima**         | 4GB                 | 8GB                   | **CPU ok**   | 4GB              | **CPU ok**        |
| **Licencia**            | CPML (no comercial) | MIT                   | Apache 2.0   | CC BY-NC-SA      | MIT               |
| **Estrellas en GitHub** | 35K+ (Coqui TTS)    | 38K+                  | 12K+         | 14K+             | 15K+              |

***

## Resumen

### XTTS v2

XTTS v2 de Coqui es el estándar de oro para TTS de clonación de voz de código abierto. Puede clonar cualquier voz a partir de un clip de audio de 3 segundos con fidelidad excepcional.

**Filosofía**: Máxima expresividad y calidad de clonación de voz.

```python
from TTS.api import TTS

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

# Clonación de voz cero-shot a partir de referencia de 3 s
tts.tts_to_file(
    text="Hello, this is a cloned voice speaking naturally.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Bark de Suno es un modelo TTS basado en transformadores que genera habla muy expresiva, incluidos sonidos no verbales: risas, suspiros, música y efectos sonoros.

**Filosofía**: No solo habla — generación de audio completa.

```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(
    "[laughs] Hello! [clears throat] This is Bark TTS. [sighs]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro es un modelo TTS ligero y rápido optimizado para inglés. A pesar de su pequeño tamaño (\~82M parámetros), ofrece una calidad sorprendentemente alta.

**Filosofía**: Modelo pequeño, gran calidad, funciona en cualquier lugar.

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

pipeline = KPipeline(lang_code='a')  # 'a' = American English

generator = pipeline(
    "The quick brown fox jumps over the lazy dog.",
    voice='af_heart',  # pre-built voice
    speed=1.0,
)

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

### Fish Speech

Fish Speech de Fish Audio es un TTS de nivel de producción con clonación de voz excepcional a partir de clips cortos. Utiliza una novedosa arquitectura de códec + modelo de lenguaje.

**Filosofía**: Calidad de producción, inferencia rápida, clonación excelente.

```python
# Fish Speech vía API HTTP
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Hello, this is Fish Speech generating audio.",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

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

### MeloTTS

MeloTTS de MyShell es un TTS ultra-rápido y multi-acento optimizado para aplicaciones en tiempo real. Funciona eficientemente en CPU y admite múltiples acentos ingleses y lenguas asiáticas.

**Filosofía**: Velocidad en tiempo real a cualquier escala.

```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(
    "Hello world! MeloTTS is very fast.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)
```

***

## Comparación de calidad

### Puntajes de naturalidad (MOS — Mean Opinion Score, 1-5)

{% hint style="info" %}
Los puntajes MOS son valores aproximados basados en artículos publicados y evaluaciones de la comunidad. La calidad real depende en gran medida del contenido del texto y la configuración de la voz.
{% endhint %}

| Modelo      | MOS en inglés | MOS multilingüe | Expresividad  |
| ----------- | ------------- | --------------- | ------------- |
| XTTS v2     | 4.3           | 4.1             | ⭐⭐⭐⭐⭐         |
| Bark        | 3.9           | 3.7             | ⭐⭐⭐⭐⭐ (único) |
| Kokoro      | 4.2           | N/D (solo EN)   | ⭐⭐⭐           |
| Fish Speech | 4.4           | 4.2             | ⭐⭐⭐⭐          |
| MeloTTS     | 3.8           | 3.6             | ⭐⭐            |

### Qué hace mejor cada modelo

| Modelo      | Característica de calidad destacada                |
| ----------- | -------------------------------------------------- |
| XTTS v2     | Clonación de voz casi perfecta, rango emocional    |
| Bark        | Sonidos no verbales, risas, música, efectos        |
| Kokoro      | Mejor relación calidad-tamaño, cadencia natural    |
| Fish Speech | Mejor naturalidad general + precisión de clonación |
| MeloTTS     | Salida consistente y limpia para textos largos     |

***

## Benchmarks de velocidad

### Caracteres por segundo (CPU vs GPU)

Prueba: "The quick brown fox jumps over the lazy dog. How are you today?" (60 chars)

| Modelo      | Velocidad en CPU       | Velocidad en GPU (RTX 3080) | Factor en tiempo real |
| ----------- | ---------------------- | --------------------------- | --------------------- |
| XTTS v2     | \~15 caracteres/s      | \~150 caracteres/s          | 0.3× (GPU)            |
| Bark        | \~5 caracteres/s       | \~40 caracteres/s           | 0.1× (GPU)            |
| Kokoro      | \~200 caracteres/s     | \~800 caracteres/s          | **5× (GPU)**          |
| Fish Speech | \~80 caracteres/s      | \~500 caracteres/s          | **3× (GPU)**          |
| MeloTTS     | **\~500 caracteres/s** | \~2000 caracteres/s         | **12× (GPU)**         |

*Factor en tiempo real > 1.0 significa más rápido que la velocidad de reproducción*

### Tiempo para generar 1 minuto de audio

| Modelo      | CPU       | RTX 3080  | A100     |
| ----------- | --------- | --------- | -------- |
| XTTS v2     | \~8 min   | \~30 s    | \~10 s   |
| Bark        | \~20 min  | \~3 min   | \~45 s   |
| Kokoro      | \~20 s    | \~5 s     | \~2 s    |
| Fish Speech | \~45 s    | \~8 s     | \~3 s    |
| MeloTTS     | **\~8 s** | **\~2 s** | **<1 s** |

{% hint style="success" %}
**Para aplicaciones en tiempo real**: MeloTTS y Kokoro son los claros ganadores. Ambos pueden generar habla más rápido que la velocidad de reproducción incluso en CPU.
{% endhint %}

***

## Soporte de idiomas

### Idiomas compatibles

| Modelo      | Idiomas | Notable                                                            |
| ----------- | ------- | ------------------------------------------------------------------ |
| 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       | Inglés (US/UK), japonés (limitado)                                 |
| Fish Speech | 8       | EN, ZH, JA, KO, FR, DE, AR, ES                                     |
| MeloTTS     | 8       | EN (4 acentos), ES, FR, ZH, JA, KO                                 |

### Notas sobre la calidad por idioma

| Modelo      | Inglés    | Chino     | Japonés   | Europeo   |
| ----------- | --------- | --------- | --------- | --------- |
| XTTS v2     | Excelente | Bueno     | Bueno     | Excelente |
| Bark        | Bueno     | Aceptable | Aceptable | Bueno     |
| Kokoro      | Excelente | ❌         | Limitado  | ❌         |
| Fish Speech | Excelente | **Mejor** | Bueno     | Bueno     |
| MeloTTS     | Bueno     | Bueno     | Bueno     | Bueno     |

{% hint style="info" %}
**Para TTS en chino**: Fish Speech y MeloTTS son las mejores opciones de código abierto. Ambos manejan tonos y caracteres de manera natural.

**Para aplicaciones multilingües**: XTTS v2 admite la mayor cantidad de idiomas con calidad consistente en todos ellos.
{% endhint %}

***

## Comparación de clonación de voz

### Capacidades de clonación

| Modelo      | Duración de referencia | Calidad de clonación | Zero-Shot |
| ----------- | ---------------------- | -------------------- | --------- |
| XTTS v2     | **3 segundos**         | ⭐⭐⭐⭐⭐                | ✅         |
| Bark        | Solo preajustes de voz | ⭐⭐⭐                  | Parcial   |
| Kokoro      | No soportado           | ❌                    | ❌         |
| Fish Speech | 10 segundos            | ⭐⭐⭐⭐⭐                | ✅         |
| MeloTTS     | No soportado           | ❌                    | ❌         |

### Clonación de voz XTTS v2

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

# Cargar modelo
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.to("cuda" if torch.cuda.is_available() else "cpu")

# Clonar voz desde referencia (mínimo 3 segundos, ideal 10-30 segundos)
tts.tts_to_file(
    text="""
    Bienvenidos a nuestro podcast. Hoy discutimos el futuro de la IA 
    y su impacto en la sociedad. Soy su anfitrión y estoy emocionado 
    de compartir con ustedes algunos insights fascinantes.
    """,
    speaker_wav="speaker_sample.wav",  # Tu audio de referencia
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Clonación de voz Fish Speech

```bash
# Clonar desde audio de referencia
fish_speech_cli tts \
  --text "This is my cloned voice speaking a new sentence." \
  --reference-audio speaker_sample.wav \
  --reference-text "The original text spoken in the reference audio." \
  --output cloned_output.wav
```

### Preajustes de voz de Bark

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

# Bark usa códigos de altavoz predefinidos
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(
    "Welcome! [laughs] This is absolutely fascinating technology.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2: Análisis profundo

### Arquitectura

* **VITS + GPT** arquitectura híbrida
* Entrenado con más de 16K horas en 17 idiomas
* Mínimo de 3 segundos para clonación zero-shot

### Instalación en Clore.ai

```bash
pip install TTS
# Versión para GPU
pip install TTS[all]
```

### Despliegue con Docker

```dockerfile
FROM nvidia/cuda:12.1.0-cudnn8-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 — API REST de XTTS v2
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
```

**Debilidades**: Licencia CPML (no comercial sin permiso), más lento que Kokoro/MeloTTS

***

## Bark: Análisis profundo

### Arquitectura

* **Transformador estilo GPT** para generación de tokens de audio
* Proceso en tres etapas: texto → semántico → tokens gruesos → finos
* Genera tokens reales de códec de audio (EnCodec)

### Qué hace único a Bark

Bark es el único TTS de código abierto que genera de forma nativa:

* 🎵 Música de fondo dentro del discurso
* 😂 Risas, suspiros, aclaramiento de garganta
* 🎭 Múltiples hablantes en una generación
* 🌍 Enunciados de idiomas mixtos

### Lenguaje de marcado

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

# Tokens especiales para expresividad
text = """
[clears throat] Good morning everyone. [laughs] 
La presentación de hoy cubrirá... 
[sighs deeply] ...en realidad bastante contenido.
[music: upbeat jazz] Let's get started!
"""

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

### Instalación

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

**Debilidades**: Lento (pipeline de 3 etapas), inconsistente entre ejecuciones, sin clonación de voz real

***

## Kokoro: Análisis profundo

### Arquitectura

* **82M parámetros** Modelo basado en StyleTTS2
* Extremadamente pequeño pero sorprendentemente de alta calidad
* Inferencia rápida en CPU y GPU

### Voces disponibles

```python
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = American English, 'b' = British

# Voces disponibles
voices = {
    'af_heart': 'American Female (warm)',
    'af_bella': 'American Female (bella)',
    'af_nicole': 'American Female (nicole)',
    'am_michael': 'American Male (michael)',
    'am_fenrir': 'American Male (fenrir)',
    'bf_emma': 'British Female (emma)',
    'bm_george': 'British Male (george)',
}

# Generar con diferentes voces
for voice_name, description in voices.items():
    gen = pipeline("Hello, this is a test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generated with {description}")
```

### Soporte de streaming

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

pipeline = KPipeline(lang_code='a')

# Transmitir audio en tiempo real mientras se genera
text = "This is a very long text that will be streamed as it generates, providing low-latency audio output."

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

**Debilidades**: Solo inglés (principalmente), sin clonación de voz, expresividad limitada

***

## Fish Speech: Análisis profundo

### Arquitectura

* **VQGAN + Modelo de lenguaje** arquitectura
* Entrenado con más de 700K horas de audio
* Fuerte multilingüe con soporte para idiomas asiáticos

### Instalación

```bash
pip install fish-speech

# O vía Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \
  +api_server.workers_count=1
```

### API de Python

```python
import httpx
import base64

# Vía API HTTP
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Hello from Fish Speech! This sounds very natural.",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)
```

### Clonación de voz

```python
# Subir referencia, obtener ID de voz
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "The text spoken in this recording."}
    )
    voice_id = response.json()["id"]

# Usar voz clonada
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Now speaking in the cloned voice.",
        "reference_id": voice_id,
    }
)
```

**Debilidades**: Licencia CC BY-NC-SA (no comercial), mayor VRAM para la mejor calidad

***

## MeloTTS: Análisis profundo

### Arquitectura

* **Basado en VITS2** arquitectura
* Entrenamiento en inglés multi-acento
* Extremadamente optimizado para velocidad de inferencia

### Acentos e idiomas

```python
from melo.api import TTS

# Códigos de idioma y acentos soportados
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

# Generar con acento británico
model.tts_to_file(
    "Cheerio! Fancy a spot of tea?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Generar con acento indio
model.tts_to_file(
    "Namaste! Welcome to our company.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### Procesamiento por lotes (Muy rápido)

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

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

texts = [
    "First sentence to synthesize.",
    "Second sentence goes here.",
    "Third and final sentence.",
]

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"Generated {len(texts)} files in {elapsed:.2f}s")
```

**Debilidades**: Sin clonación de voz, robótico a alta velocidad, expresividad limitada

***

## Despliegue en Clore.ai

### Servidor TTS todo en uno

```yaml
# docker-compose.yml — Servicio TTS con múltiples backends
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"
    # ¡No se necesita 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]
```

### Resumen de requisitos de VRAM

| Modelo      | CPU            | GPU de 4 GB | GPU de 8 GB | GPU de 16 GB |
| ----------- | -------------- | ----------- | ----------- | ------------ |
| XTTS v2     | Lento          | ✅           | ✅           | ✅            |
| Bark        | Muy lento      | ❌           | ✅           | ✅            |
| Kokoro      | **Rápido**     | ✅           | ✅           | ✅            |
| Fish Speech | Medio          | ✅           | ✅           | ✅            |
| MeloTTS     | **Muy rápido** | ✅           | ✅           | ✅            |

***

## Ejemplos de integración

### API compatible con OpenAI (para reemplazo directo)

```python
# Muchos servidores TTS ofrecen endpoints compatibles con OpenAI
# Use Kokoro FastAPI o similar

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # Tu servidor TTS
    api_key="not-needed"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hello world! This uses the OpenAI TTS API format.",
)
response.stream_to_file("output.mp3")
```

### Integración con LangChain

```python
# Usando TTS con LangChain para agentes de voz
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="Convertir texto en archivo de audio"
)
```

***

## Cuándo usar cada uno

### Guía de decisión

```
¿Necesitas clonación de voz a partir de un clip corto?
  → XTTS v2 (referencia de 3 s) o Fish Speech (referencia de 10 s)

¿Necesitas generación en tiempo real / más rápida?
  → MeloTTS (amigable con CPU) o Kokoro

¿Necesitas habla expresiva (risa, emoción)?
  → Bark (sonidos no verbales únicos) o XTTS v2

¿Necesitas chino/japonés/coreano?
  → Fish Speech (mejor para CJK) o MeloTTS

Solo inglés, ¿calidad máxima?
  → Kokoro (mejor relación tamaño/calidad)

¿Necesitas más de 17 idiomas?
  → XTTS v2

¿Uso comercial permitido?
  → Kokoro (Apache) o MeloTTS (MIT) o Bark (MIT)

¿Investigación no comercial?
  → Cualquiera (XTTS v2 CPML o Fish Speech CC BY-NC-SA)
```

### Por tipo de aplicación

| Aplicación                    | Mejor opción          | Por qué                     |
| ----------------------------- | --------------------- | --------------------------- |
| Generación de audiolibros     | XTTS v2               | Voz natural y consistente   |
| Chatbot en tiempo real        | MeloTTS o Kokoro      | Inferencia más rápida       |
| Automatización de podcasts    | XTTS v2 o Fish Speech | Mejor clonación             |
| Personajes de juegos          | Bark                  | Voces expresivas y variadas |
| Atención al cliente           | MeloTTS               | Escalable y rápido          |
| Herramientas de accesibilidad | Kokoro                | Ligero y gratuito           |
| Doblaje de voz                | Fish Speech           | Mejor calidad de clonación  |
| Narración de larga duración   | XTTS v2               | Calidad consistente         |

***

## Resumen de licencias

{% hint style="warning" %}
**¡La licencia importa para el uso comercial!** Revisa siempre antes de desplegar en producción.
{% endhint %}

| Modelo      | Licencia                   | ¿Comercial? | Notas                                |
| ----------- | -------------------------- | ----------- | ------------------------------------ |
| XTTS v2     | Coqui Public Model License | ❌ Gratis    | Requiere licencia para uso comercial |
| Bark        | MIT                        | ✅           | Gratis para todo uso                 |
| Kokoro      | Apache 2.0                 | ✅           | Gratis para todo uso                 |
| Fish Speech | CC BY-NC-SA 4.0            | ❌           | Solo no comercial                    |
| MeloTTS     | MIT                        | ✅           | Gratis para todo uso                 |

**Totalmente abierto para uso comercial**: Bark, Kokoro, MeloTTS

***

## Costo en Clore.ai

```
Kokoro/MeloTTS (CPU o GPU económica):
  Servidor más barato a ~$0.05/h → ~$36/mes
  Puede manejar 100+ solicitudes concurrentes en CPU

XTTS v2 (RTX 3080):
  ~$0.30/h → ~$220/mes
  Capacidad de ~500 solicitudes/h

Fish Speech (RTX 4090):
  ~$0.60/h → ~$440/mes  
  Capacidad de ~1000 solicitudes/h
```

***

## Enlaces útiles

* [Coqui TTS (XTTS)](https://github.com/coqui-ai/TTS) — 35K+ estrellas
* [Bark GitHub](https://github.com/suno-ai/bark) — 38K+ estrellas
* [Kokoro GitHub](https://github.com/hexgrad/kokoro) — 12K+ estrellas
* [Fish Speech GitHub](https://github.com/fishaudio/fish-speech) — 14K+ estrellas
* [MeloTTS GitHub](https://github.com/myshell-ai/MeloTTS) — 15K+ estrellas
* [Tabla de clasificación TTS Arena](https://huggingface.co/spaces/TTS-AGI/TTS-Arena)

***

## Resumen

| Modelo          | Usar cuando                                                       |
| --------------- | ----------------------------------------------------------------- |
| **XTTS v2**     | Mejor clonación de voz (referencia 3 s), 17 idiomas, no comercial |
| **Bark**        | Expresivo, risas/efectos, licencia MIT                            |
| **Kokoro**      | Rápido, alta calidad en inglés, licencia Apache                   |
| **Fish Speech** | Mejor para CJK, clonación en producción, no comercial             |
| **MeloTTS**     | El más rápido, en tiempo real, inglés multiacento, licencia MIT   |

Para la mayoría de despliegues de Clore.ai en producción:

* **Aplicaciones de voz en tiempo real** → MeloTTS o Kokoro (gratis, rápido, MIT)
* **Servicio de clonación de voz** → XTTS v2 o Fish Speech (verificar licencias)
* **Narración expresiva** → Bark o XTTS v2

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso        | GPU recomendada | Coste estimado en Clore.ai |
| ------------------ | --------------- | -------------------------- |
| Desarrollo/Pruebas | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Producción         | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Gran escala        | A100 80GB       | \~$1.20/gpu/hr             |

> 💡 Todos los ejemplos en esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# Agent Instructions: 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-es/comparaciones/tts-comparison.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.