# Text Generation WebUI

Ejecuta la interfaz de LLM más popular con soporte para todos los formatos de modelo.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis Pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Por qué Text Generation WebUI?

* Admite formatos GGUF, GPTQ, AWQ, EXL2, HF
* Modos integrados: chat, cuaderno y API
* Extensiones: voz, personajes, multimodal
* Soporte para fine-tuning
* Cambio de modelo sobre la marcha

## Requisitos

| Tamaño del modelo | VRAM mínima | Recomendado |
| ----------------- | ----------- | ----------- |
| 7B (Q4)           | 6GB         | RTX 3060    |
| 13B (Q4)          | 10GB        | RTX 3080    |
| 30B (Q4)          | 20GB        | RTX 4090    |
| 70B (Q4)          | 40GB        | A100        |

## Despliegue rápido

**Imagen Docker:**

```
atinoda/text-generation-webui:default-nvidia
```

**Puertos:**

```
22/tcp
7860/http
5000/http
5005/http
```

**Entorno:**

```
EXTRA_LAUNCH_ARGS=--listen --api
```

## Instalación manual

**Imagen:**

```
nvidia/cuda:12.1.0-devel-ubuntu22.04
```

**Puertos:**

```
22/tcp
7860/http
5000/http
```

**Comando:**

```bash
apt-get update && apt-get install -y git python3 python3-pip && \
cd /workspace && \
git clone https://github.com/oobabooga/text-generation-webui.git && \
cd text-generation-webui && \
pip install -r requirements.txt && \
python server.py --listen --api
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

## Acceder a WebUI

1. Esperar a que se despliegue
2. Buscar el mapeo del puerto 7860 en **Mis Pedidos**
3. Abrir: `http://<proxy>:<port>`

## Descargar modelos

### Desde HuggingFace (en WebUI)

1. Ir a **Modelo** pestaña
2. Ingrese el nombre del modelo: `bartowski/Meta-Llama-3.1-8B-Instruct-GGUF`
3. Hacer clic **Descargar**

### Vía línea de comandos

```bash
cd /workspace/text-generation-webui

# Descargar modelo GGUF
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Descargar archivo específico
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF --specific-file Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
```

### Modelos recomendados

**Para chat:**

```bash

# Llama 2 Chat (7B, rápido)
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Mistral Instruct (excelente)
python download-model.py bartowski/Mistral-7B-Instruct-v0.3-GGUF

# OpenHermes (gran todoterreno)
python download-model.py bartowski/OpenHermes-2.5-Mistral-7B-GGUF
```

**Para programación:**

```bash

# CodeLlama
python download-model.py bartowski/CodeLlama-13B-Instruct-GGUF

# DeepSeek Coder
python download-model.py bartowski/DeepSeek-Coder-V2-Lite-Instruct-GGUF
```

**Para juegos de roles:**

```bash

# MythoMax
python download-model.py bartowski/MythoMax-L2-13B-GGUF
```

## Cargando modelos

### GGUF (Recomendado para la mayoría de los usuarios)

1. **Modelo** pestaña → Seleccionar carpeta del modelo
2. **Cargador de modelos:** llama.cpp
3. Establecer **n-gpu-layers:**
   * RTX 3090: 35-40
   * RTX 4090: 45-50
   * A100: 80+
4. Hacer clic **Cargar**

### GPTQ (rápido, cuantizado)

1. Descargar modelo GPTQ
2. **Cargador de modelos:** ExLlama\_HF o AutoGPTQ
3. Cargar modelo

### EXL2 (Mejor velocidad)

```bash

# Instalar exllamav2
pip install exllamav2
```

1. Descargar modelo EXL2
2. **Cargador de modelos:** ExLlamav2\_HF
3. Cargar

## Configuración de chat

### Configuración de personaje

1. Ir a **Parámetros** → **Personaje**
2. Crear o cargar ficha de personaje
3. Establecer:
   * Nombre
   * Contexto/persona
   * Diálogo de ejemplo

### Modo Instruct

Para modelos afinados con instrucciones:

1. **Parámetros** → **Plantilla de instrucción**
2. Seleccionar la plantilla que coincida con su modelo:
   * Llama-2-chat
   * Mistral
   * ChatML
   * Alpaca

## Uso de la API

### Habilitar API

Comience con `--api` bandera (puerto predeterminado 5000)

### API compatible con OpenAI

```python
import openai

openai.api_base = "http://localhost:5000/v1"
openai.api_key = "no-necesaria"

response = openai.ChatCompletion.create(
    model="cualquiera",
    messages=[{"role": "user", "content": "¡Hola!"}]
)
print(response.choices[0].message.content)
```

### API nativa

```python
import requests

response = requests.post(
    "http://localhost:5000/api/v1/generate",
    json={
        "prompt": "Escribe una historia sobre",
        "max_new_tokens": 200,
        "temperature": 0.7
    }
)
print(response.json()["results"][0]["text"])
```

## Extensiones

### Instalando extensiones

```bash
cd /workspace/text-generation-webui/extensions

# Silero TTS (voz)
git clone https://github.com/oobabooga/text-generation-webui-extensions

# SuperBoogav2 (RAG/memoria a largo plazo)

# Ya incluido, habilitar en la UI
```

### Habilitar extensiones

1. **Sesión** pestaña → **Extensiones**
2. Marcar las casillas de las extensiones deseadas
3. Hacer clic **Aplicar y reiniciar**

### Extensiones populares

| Extensión         | Propósito                               |
| ----------------- | --------------------------------------- |
| silero\_tts       | Salida de voz                           |
| whisper\_stt      | Entrada de voz                          |
| superbooga        | Preguntas y respuestas sobre documentos |
| sd\_api\_pictures | Generación de imágenes                  |
| multimodal        | Comprensión de imágenes                 |

## Ajuste de rendimiento

### Configuración GGUF

```
n_gpu_layers: 35    # Capas de GPU (más = más rápido)
n_ctx: 4096         # Longitud del contexto
n_batch: 512        # Tamaño del lote
threads: 8          # Hilos de CPU
```

### Optimización de memoria

Para VRAM limitada:

```bash
python server.py --listen --n-gpu-layers 20 --no-mmap
```

### Optimización de velocidad

```bash

# Usar llama.cpp con cuBLAS
python server.py --listen --loader llama.cpp --n-gpu-layers 50 --threads 8
```

## Ajuste fino (LoRA)

### Pestaña de entrenamiento

1. Ir a **Entrenamiento** pestaña
2. Cargar modelo base
3. Subir conjunto de datos (formato JSON)
4. Configurar:
   * Rango LoRA: 8-32
   * Tasa de aprendizaje: 1e-4
   * Épocas: 3-5
5. Iniciar entrenamiento

### Formato del conjunto de datos

```json
[
  {"instruction": "Resume esto:", "input": "Texto largo...", "output": "Resumen..."},
  {"instruction": "Traducir al francés:", "input": "Hello", "output": "Bonjour"}
]
```

## Guardando tu trabajo

```bash

# Guardar modelos
rsync -avz /workspace/text-generation-webui/models/ backup-server:/models/

# Guardar personajes
rsync -avz /workspace/text-generation-webui/characters/ backup-server:/characters/

# Guardar LoRAs
rsync -avz /workspace/text-generation-webui/loras/ backup-server:/loras/
```

## Solución de problemas

### El modelo no se carga

* Comprobar el uso de VRAM: `nvidia-smi`
* Reducir `n_gpu_layers`
* Usar cuantización más pequeña (Q4\_K\_M → Q4\_K\_S)

### Generación lenta

* Aumente `n_gpu_layers`
* Usar EXL2 en lugar de GGUF
* Habilite `--no-mmap`

{% hint style="danger" %}
**Fuera de memoria**
{% endhint %}

durante la generación - Reducir \`n\_ctx\` (longitud del contexto) - Usar \`--n-gpu-layers 0\` para solo CPU - Probar un modelo más pequeño

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** market para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores