# Kokoro TTS

Kokoro es un modelo de texto a voz de 82 millones de parámetros que rinde mucho más de lo que su categoría sugiere. A pesar de su tamaño diminuto (menos de 2 GB de VRAM), produce un habla en inglés notablemente natural y se ejecuta a velocidades en tiempo real o superiores incluso en hardware económico. Con licencia Apache 2.0, múltiples estilos de voz incorporados y soporte de inferencia en CPU, Kokoro es ideal para aplicaciones en tiempo real, chatbots y despliegues en el edge.

**HuggingFace:** [hexgrad/Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) **PyPI:** [kokoro](https://pypi.org/project/kokoro/) **Licencia:** Apache 2.0

## Características clave

* **82M parámetros** — uno de los modelos TTS de alta calidad más pequeños disponibles
* **< 2 GB VRAM** — se ejecuta en prácticamente cualquier GPU e incluso en CPU
* **Múltiples estilos de voz** — inglés americano, inglés británico; voces masculinas y femeninas
* **En tiempo real o más rápido** — inferencia de baja latencia adecuada para streaming
* **Generación en streaming** — produce fragmentos de audio a medida que se generan
* **Soporte multilingüe** — inglés (principal), japonés (`misaki[ja]`), chino (`misaki[zh]`)
* **Apache 2.0** — gratis para uso personal y comercial

## Requisitos

| Componente | Mínimo                   | Recomendado |
| ---------- | ------------------------ | ----------- |
| GPU        | Cualquiera con 2 GB VRAM | RTX 3060    |
| VRAM       | 2 GB                     | 4 GB        |
| RAM        | 4 GB                     | 8 GB        |
| Disco      | 500 MB                   | 1 GB        |
| Python     | 3.9+                     | 3.11        |
| Sistema    | espeak-ng instalado      | —           |

**Recomendación de Clore.ai:** Una RTX 3060 (\~$0.15–0.30/día) es más que suficiente. Kokoro incluso puede ejecutarse en instancias solo con CPU para TTS extremadamente rentable.

## Instalación

```bash
# Instalar dependencia del sistema
apt-get install -y espeak-ng

# Instalar Kokoro y E/S de audio
pip install kokoro>=0.9.4 soundfile torch

# Para soporte de japonés (opcional)
pip install misaki[ja]

# Para soporte de chino (opcional)
pip install misaki[zh]

# Verificar
python -c "from kokoro import KPipeline; print('Kokoro listo')"
```

## Inicio rápido

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

# Inicializar pipeline
# 'a' = inglés americano, 'b' = inglés británico
pipeline = KPipeline(lang_code='a')

text = """
Kokoro es un modelo de texto a voz ligero con solo ochenta y dos millones
de parámetros. A pesar de su pequeño tamaño, produce un habla natural y expresiva.
"""

# Generar audio — opciones de voz: 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"Fragmento {i}: {graphemes[:50]}...")

print("¡Hecho!")
```

## Ejemplos de uso

### Comparación de múltiples voces

Genera el mismo texto con diferentes voces para comparar:

```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"Generado: {voice}")
```

### Inglés británico con control de velocidad

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

# 'b' = inglés británico
pipeline = KPipeline(lang_code='b')

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

# speed < 1.0 = más lento, speed > 1.0 = más rápido
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"Duración total: {len(combined)/24000:.1f}s")
```

### Procesamiento por lotes de archivos

Procesa múltiples textos y concaténalos en un único archivo al estilo audiolibro:

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

pipeline = KPipeline(lang_code='a')

chapters = [
    "Capítulo uno. El comienzo de nuestro viaje comienza aquí.",
    "El sol se elevó sobre las montañas, proyectando largas sombras a través del valle.",
    "Ella abrió la puerta y dio un paso hacia lo desconocido.",
]

all_audio = []
silence = np.zeros(int(24000 * 0.5))  # 0.5s de silencio entre capítulos

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"Capítulo {idx+1} terminado")

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

## Consejos para usuarios de Clore.ai

* **Inferencia en CPU** — Kokoro es lo suficientemente pequeño como para ejecutarse en CPU; útil para cargas de trabajo sensibles al costo o cuando no hay GPUs disponibles
* **Streaming** — el generador produce fragmentos de audio a medida que se generan, lo que permite la reproducción en tiempo real en aplicaciones web
* **Combinar con WhisperX** — usa WhisperX para transcripción y Kokoro para re-síntesis en pipelines de voz
* **Docker** — usar `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime` y añade `apt-get install -y espeak-ng` a tu inicio
* **Consistencia de voz** — mantén un ID de voz por proyecto para una experiencia de narrador consistente
* **Eficiencia de costes** — a $0.15/día en una RTX 3060, Kokoro es una de las soluciones TTS más baratas para alojar uno mismo

## Solución de problemas

| Problema                      | Solución                                                                                                      |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `espeak-ng no encontrado`     | Ejecuta `apt-get install -y espeak-ng` (dependencia del sistema requerida)                                    |
| `ModuleNotFoundError: kokoro` | Instalar con `pip install kokoro>=0.9.4 soundfile`                                                            |
| El audio suena robótico       | Prueba una voz diferente (por ejemplo, `af_heart` tiende a sonar más natural)                                 |
| Japonés/Chino no funciona     | Instala los extras de idioma: `pip install misaki[ja]` o `misaki[zh]`                                         |
| Agotamiento de memoria en CPU | Reduce la longitud del texto por llamada; Kokoro transmite fragmentos para que la memoria se mantenga acotada |
| Primera ejecución lenta       | Descarga de pesos del modelo en el primer uso (\~200 MB); las ejecuciones posteriores son instantáneas        |


---

# 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/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.