# Voxtral TTS

> **El modelo de texto a voz de pesos abiertos de Mistral: 4B parámetros, 9 idiomas, clonación de voz zero-shot, solo 3 GB de VRAM.**

| Especificación       | Valor                                                                            |
| -------------------- | -------------------------------------------------------------------------------- |
| **Desarrollador**    | Mistral AI                                                                       |
| **Parámetros**       | 4 mil millones                                                                   |
| **Arquitectura**     | TTS solo decodificador                                                           |
| **Idiomas**          | 9 (inglés, francés, alemán, español, hindi, árabe, portugués, italiano, japonés) |
| **Licencia**         | Apache 2.0 (pesos abiertos)                                                      |
| **VRAM**             | \~3 GB (FP16)                                                                    |
| **Latencia**         | 70 ms para una salida de 10 segundos                                             |
| **Clonación de voz** | Zero-shot a partir de una referencia de 3 segundos                               |
| **Lanzamiento**      | 26 de marzo de 2026                                                              |

## ¿Por qué Voxtral TTS?

Voxtral TTS es la respuesta de pesos abiertos de Mistral a ElevenLabs y OpenAI TTS. Ventajas clave para los usuarios de Clore.ai:

* **Funciona en cualquier GPU** — solo 3 GB de VRAM significa que incluso una RTX 3060 funciona perfectamente
* **Sin tarifas de API** — autoalojado = síntesis ilimitada con costo marginal cero
* **Privacidad de datos** — el audio nunca sale de tu máquina
* **Clonación zero-shot** — clona cualquier voz a partir de 3 segundos de audio de referencia
* **9 idiomas de forma nativa** — incluyendo hindi y árabe, que a menudo faltan en la competencia
* **Velocidad en tiempo real** — RTF 0.1–0.2× en RTX 4070+ (clip de 10 segundos en 1–2 segundos)

## Requisitos de GPU en Clore.ai

| GPU           | VRAM  | Rendimiento                                 | Precio en Clore.ai |
| ------------- | ----- | ------------------------------------------- | ------------------ |
| RTX 3060 12GB | 12 GB | ✅ Bueno — 3–4× en tiempo real               | desde $0.10/día    |
| RTX 3090 24GB | 24 GB | ✅ Excelente — procesamiento por lotes       | desde $0.30/día    |
| RTX 4070 12GB | 12 GB | ✅ Excelente — 5–10× en tiempo real          | desde $0.25/día    |
| RTX 4090 24GB | 24 GB | ✅ Excesivo — latencia inferior a un segundo | desde $0.50/día    |

> **Recomendación:** Una RTX 3060 12GB ($0.10/día en Clore.ai) es el punto óptimo para la mayoría de los casos de uso. Voxtral solo necesita 3 GB de VRAM, así que puedes ejecutarlo junto con otros modelos.

## Inicio rápido en Clore.ai

### Paso 1: Alquila un servidor GPU

1. Ve a [Marketplace de Clore.ai](https://clore.ai/marketplace)
2. Filtra cualquier GPU con 8+ GB de VRAM
3. Selecciona un despliegue de **Docker** despliegue
4. Usa la imagen: `pytorch/pytorch:2.4.0-cuda12.4-cudnn9-devel`

### Paso 2: Instala las dependencias

```bash
# Conéctate por SSH o terminal de Jupyter
pip install torch torchaudio transformers accelerate

# Instala el paquete Voxtral TTS
pip install voxtral-tts

# O usa HuggingFace directamente
pip install huggingface_hub
huggingface-cli download mistralai/Voxtral-TTS --local-dir ./voxtral-tts
```

### Paso 3: Texto a voz básico

```python
from voxtral import VoxtralTTS

# Inicializa el modelo (descarga automáticamente los pesos ~6 GB)
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS")
model.to("cuda")

# Síntesis básica
audio = model.synthesize(
    text="Bienvenido a Clore.ai — el marketplace descentralizado de GPU.",
    language="en"
)
audio.save("output.wav")
print(f"Se generaron {audio.duration:.1f}s de audio")
```

### Paso 4: Clonación de voz zero-shot

```python
# Clona una voz a partir de una referencia de 3 segundos
audio = model.synthesize(
    text="Esta es mi voz clonada hablando sobre computación con GPU.",
    reference_audio="reference_speaker.wav",  # 3+ segundos
    language="en"
)
audio.save("cloned_output.wav")
```

### Paso 5: Síntesis multilingüe

```python
# Sintetiza en 9 idiomas compatibles
languages = {
    "en": "Hola, habla Voxtral en inglés.",
    "fr": "Bonjour, c'est Voxtral qui parle en français.",
    "de": "Hola, habla Voxtral en alemán.",
    "es": "Hola, Voxtral hablando en español.",
    "hi": "नमस्ते, यह Voxtral हिंदी में बोल रहा है।",
    "ar": "مرحبا، هذا Voxtral يتحدث بالعربية.",
    "pt": "Hola, aquí está Voxtral hablando en portugués.",
    "it": "Hola, habla Voxtral en italiano.",
    "ja": "こんにちは、Voxtralが日本語で話しています。",
}

for lang, text in languages.items():
    audio = model.synthesize(text=text, language=lang)
    audio.save(f"voxtral_{lang}.wav")
    print(f"[{lang}] Se generaron {audio.duration:.1f}s")
```

## Servidor API de producción

Despliega Voxtral como una API REST para integrarlo en tus aplicaciones:

```python
# server.py — envoltorio FastAPI para Voxtral TTS
from fastapi import FastAPI, UploadFile, File
from fastapi.responses import StreamingResponse
from voxtral import VoxtralTTS
import io
import soundfile as sf

app = FastAPI(title="API de Voxtral TTS")
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

@app.post("/synthesize")
async def synthesize(
    text: str,
    language: str = "en",
    reference: UploadFile = File(None)
):
    kwargs = {"text": text, "language": language}
    if reference:
        ref_bytes = await reference.read()
        kwargs["reference_audio"] = ref_bytes
    
    audio = model.synthesize(**kwargs)
    
    # Devuelve como flujo WAV
    buffer = io.BytesIO()
    sf.write(buffer, audio.numpy(), samplerate=24000, format="WAV")
    buffer.seek(0)
    
    return StreamingResponse(buffer, media_type="audio/wav")

@app.get("/health")
async def health():
    return {"status": "ok", "model": "voxtral-tts", "languages": 9}
```

```bash
# Ejecuta el servidor API
pip install fastapi uvicorn python-multipart soundfile
uvicorn server:app --host 0.0.0.0 --port 8000

# Pruébalo
curl -X POST "http://localhost:8000/synthesize?text=Hello%20world&language=en" \
  --output hello.wav
```

## Despliegue con Docker

```dockerfile
FROM pytorch/pytorch:2.4.0-cuda12.4-cudnn9-devel

WORKDIR /app
RUN pip install voxtral-tts fastapi uvicorn python-multipart soundfile

# Predescarga los pesos del modelo
RUN python -c "from voxtral import VoxtralTTS; VoxtralTTS.from_pretrained('mistralai/Voxtral-TTS')"

COPY server.py .
EXPOSE 8000
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]
```

```bash
# Construye y ejecuta
docker build -t voxtral-tts-api .
docker run --gpus all -p 8000:8000 voxtral-tts-api
```

## Voxtral vs otros modelos TTS

| Característica       | Voxtral TTS       | ElevenLabs        | Qwen3-TTS         | Kokoro TTS | Fish Speech        |
| -------------------- | ----------------- | ----------------- | ----------------- | ---------- | ------------------ |
| **Pesos abiertos**   | ✅ Apache 2.0      | ❌ Solo API        | ✅                 | ✅          | ✅                  |
| **VRAM**             | 3 GB              | N/D (nube)        | 8 GB              | 2 GB       | 4 GB               |
| **Idiomas**          | 9                 | 30+               | 50+               | 5          | 8                  |
| **Clonación de voz** | referencia de 3 s | referencia de 1 s | referencia de 5 s | ❌          | referencia de 10 s |
| **Latencia**         | 70 ms             | \~200 ms          | \~150 ms          | 50 ms      | 100 ms             |
| **Calidad**          | ⭐⭐⭐⭐⭐             | ⭐⭐⭐⭐⭐             | ⭐⭐⭐⭐              | ⭐⭐⭐⭐       | ⭐⭐⭐⭐               |
| **Autoalojado**      | ✅                 | ❌                 | ✅                 | ✅          | ✅                  |

## Procesamiento por lotes para proyectos grandes

```python
import concurrent.futures
from voxtral import VoxtralTTS

model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

# Procesa un capítulo entero de audiolibro
paragraphs = [
    "Capítulo 1: El comienzo...",
    "Era una noche oscura y tormentosa...",
    "El protagonista dio un paso adelante...",
    # ... cientos de párrafos
]

def process_paragraph(idx_text):
    idx, text = idx_text
    audio = model.synthesize(text=text, language="en")
    audio.save(f"chapter1_part{idx:04d}.wav")
    return idx

# Procesamiento secuencial (limitado por GPU)
for i, text in enumerate(paragraphs):
    process_paragraph((i, text))
    
print(f"Se procesaron {len(paragraphs)} párrafos")
```

## Modo streaming para aplicaciones en tiempo real

```python
# Síntesis en streaming para aplicaciones en vivo
async def stream_synthesis(text: str, language: str = "en"):
    """Genera audio en fragmentos en streaming para reproducción de baja latencia."""
    model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")
    
    async for chunk in model.synthesize_stream(
        text=text,
        language=language,
        chunk_size=4096  # ~170 ms por fragmento a 24 kHz
    ):
        yield chunk.numpy().tobytes()
```

## Solución de problemas

| Problema                      | Solución                                                                                                    |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------- |
| OOM en GPU pequeña            | Usa `model.half()` para FP16 (reduce la VRAM a la mitad hasta \~1.5 GB)                                     |
| Primera inferencia lenta      | Normal — el modelo compila los kernels CUDA en la primera ejecución (\~30 s)                                |
| Mala calidad para el idioma X | Asegúrate de usar el parámetro `language` correcto; algunos idiomas necesitan audio de referencia más largo |
| Artefactos de audio           | Aumenta `reference_audio` la longitud a 5–10 s para una mejor clonación de voz                              |
| Falla la descarga del modelo  | Configura `HF_TOKEN` como variable de entorno para acceso a modelos restringidos                            |

## Análisis de costos: Voxtral en Clore.ai vs TTS en la nube

| Servicio                | 1M caracteres/mes | Notas                                            |
| ----------------------- | ----------------- | ------------------------------------------------ |
| ElevenLabs Pro          | $99/mes           | 500K caracteres incluidos, tarifas por excedente |
| OpenAI TTS              | $15/mes           | $15 por 1M de caracteres                         |
| Google Cloud TTS        | $16/mes           | Voces estándar                                   |
| **Voxtral en Clore.ai** | **$3–15/mes**     | RTX 3060 @ $0.10–0.50/día, caracteres ilimitados |

> **En resumen:** Autoalojar Voxtral en Clore.ai es 6–30× más barato que las API TTS en la nube, con cero límites de caracteres y privacidad total de los datos.

## Lecturas adicionales

* [Voxtral TTS en HuggingFace](https://huggingface.co/mistralai/Voxtral-TTS)
* [Blog de Mistral AI — Anuncio de Voxtral](https://mistral.ai/news/voxtral-tts)
* [Compara modelos TTS en Clore.ai](/guides/guides_v2-es/comparaciones/tts-comparison.md)
* [Otras guías de audio y voz](/guides/guides_v2-es/audio-y-voz/audio-voice.md)

***

*Última actualización: 30 de marzo de 2026*


---

# 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/audio-y-voz/voxtral-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.