> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/text-generation-webui.md).

# Text Generation WebUI

Ejecuta text-generation-webui para inferencia de LLM en GPUs de Clore.ai

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 [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al 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 y HF
* Modos integrados de chat, cuaderno y API
* Extensiones: voz, personajes, multimodal
* Soporte para ajuste fino
* 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)          | 20 GB       | RTX 4090    |
| 70B (Q4)          | 40 GB       | A100        |

## Despliegue rápido

**Imagen de 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.8.1-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. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Accede a WebUI

1. Espera a que se implemente
2. Encuentra el mapeo del puerto 7860 en **Mis pedidos**
3. Abre: `http://<proxy>:<port>`

## Descargar modelos

### Desde HuggingFace (en WebUI)

1. Ve a **Modelo** pestaña
2. Introduce el nombre del modelo: `bartowski/Meta-Llama-3.1-8B-Instruct-GGUF`
3. Haz clic en **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 roleplay:**

```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 → Selecciona la carpeta del modelo
2. **Cargador del modelo:** llama.cpp
3. Establece **n-gpu-layers:**
   * RTX 3090: 35-40
   * RTX 4090: 45-50
   * A100: 80+
4. Haz clic en **Cargar**

### GPTQ (rápido, cuantizado)

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

### EXL2 (mejor velocidad)

```bash

# Instalar exllamav2
pip install exllamav2
```

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

## Configuración del chat

### Configuración del personaje

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

### Modo instruct

Para modelos ajustados con instrucciones:

1. **Parámetros** → **Plantilla de instrucciones**
2. Selecciona la plantilla que coincida con tu modelo:
   * Llama-2-chat
   * Mistral
   * ChatML
   * Alpaca

## Uso de la API

### Activar API

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

### API compatible con OpenAI

```python
import openai

openai.api_base = "http://localhost:5000/v1"
openai.api_key = "not-needed"

response = openai.ChatCompletion.create(
    model="any",
    messages=[{"role": "user", "content": "Hello!"}]
)
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

### Instalación de 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, actívalo en la interfaz
```

### Activar extensiones

1. **Sesión** pestaña → **Extensiones**
2. Marca las casillas de las extensiones deseadas
3. Haz clic en **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 del rendimiento

### Configuración de 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 de 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

# Usa 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. Ve a **Entrenamiento** pestaña
2. Cargar modelo base
3. Sube el conjunto de datos (formato JSON)
4. Configura:
   * Rango de LoRA: 8-32
   * Tasa de aprendizaje: 1e-4
   * Épocas: 3-5
5. Inicie el entrenamiento

### Formato del conjunto de datos

```json
[
  {"instruction": "Resume esto:", "input": "Texto largo...", "output": "Resumen..."},
  {"instruction": "Traduce al francés:", "input": "Hola", "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

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

### Generación lenta

* Aumenta `n_gpu_layers`
* Usa EXL2 en lugar de GGUF
* Habilita `--no-mmap`

{% hint style="danger" %}
**Sin memoria**
{% endhint %}

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

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/text-generation-webui.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
