# 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


---

# 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/modelos-de-lenguaje/text-generation-webui.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.