> 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/aphrodite-engine.md).

# Aphrodite Engine

Ejecuta Aphrodite Engine para inferencia de LLM en GPUs antiguas y modernas en Clore.ai

Aphrodite Engine es un servidor de inferencia LLM optimizado construido sobre vLLM, diseñado específicamente para la comunidad de escritura creativa y roleplay. Admite una amplia gama de GPUs desde Pascal (serie GTX 1000), lo que lo convierte en la opción perfecta para ejecutar modelos de lenguaje en servidores GPU CLORE.AI antiguos o económicos donde otros marcos fallan. Aphrodite añade APIs compatibles con Kobold, muestreo Mirostat y algoritmos avanzados de muestreo de texto que no se encuentran en los marcos de servicio convencionales.

{% 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 %}

## Requisitos del servidor

| Parámetro | Mínimo                     | Recomendado    |
| --------- | -------------------------- | -------------- |
| RAM       | 16 GB                      | 32 GB+         |
| VRAM      | 6 GB                       | 16 GB+         |
| Disco     | 40 GB                      | 150 GB+        |
| GPU       | NVIDIA Pascal+ (GTX 1060+) | RTX 3090, A100 |

{% hint style="info" %}
Aphrodite Engine es uno de los pocos servidores LLM que admiten GPUs de la generación Pascal (serie GTX 10xx). Esto lo hace ideal para servidores económicos en CLORE.AI con GPUs antiguas y precios de alquiler bajos.
{% endhint %}

## Despliegue rápido en CLORE.AI

**Imagen de Docker:** `alpindale/aphrodite-engine:latest`

**Puertos:** `22/tcp`, `2242/http`

**Variables de entorno:**

| Variable          | Ejemplo                              | Descripción                                    |
| ----------------- | ------------------------------------ | ---------------------------------------------- |
| `HF_TOKEN`        | `hf_xxx...`                          | Token de HuggingFace para modelos restringidos |
| `APHRODITE_MODEL` | `mistralai/Mistral-7B-Instruct-v0.3` | Modelo a cargar                                |

## Configuración paso a paso

### 1. Alquila un servidor GPU en CLORE.AI

La amplia compatibilidad de GPUs de Aphrodite te permite conseguir servidores económicos en [Marketplace de CLORE.AI](https://clore.ai/marketplace):

* **Pascal (GTX 1060–1080 Ti)**: 6–11 GB de VRAM — ejecuta modelos pequeños de 3B-7B con cuantización
* **Turing (serie RTX 2000)**: 8–24 GB de VRAM — modelos 7B-13B, mejor rendimiento
* **Ampere (RTX 3000/A100)**: 24–80 GB de VRAM — modelos 30B-70B, velocidad completa
* **Ada (serie RTX 4000)**: 16–24 GB de VRAM — mejor relación rendimiento/coste

### 2. Conéctate vía SSH

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Descarga la imagen de Aphrodite Engine

```bash
docker pull alpindale/aphrodite-engine:latest
```

### 4. Inicia Aphrodite Engine

**Inicio básico con un modelo 7B:**

```bash
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.3 \
    --host 0.0.0.0 \\
    --port 2242 \
    --max-model-len 4096
```

**Con token de HuggingFace (Llama 3):**

```bash
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your_token_here \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model meta-llama/Meta-Llama-3-8B-Instruct \
    --host 0.0.0.0 \\
    --port 2242 \
    --dtype bfloat16 \\
    --max-model-len 8192
```

**Con cuantización GPTQ (para VRAM limitada):**

```bash
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model TheBloke/Mistral-7B-Instruct-v0.2-GPTQ \
    --host 0.0.0.0 \\
    --port 2242 \
    --quantization gptq \
    --max-model-len 4096
```

**Con cuantización AWQ:**

```bash
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model casperhansen/mistral-7b-instruct-v0.2-awq \
    --host 0.0.0.0 \\
    --port 2242 \
    --quantization awq \\
    --max-model-len 4096
```

**Ejecutando un modelo GGUF (Aphrodite admite GGUF de forma nativa):**

```bash
# Primero descarga el archivo GGUF
docker exec -it aphrodite bash -c "
pip install huggingface_hub
python3 -c \"from huggingface_hub import hf_hub_download; hf_hub_download(
    repo_id='TheBloke/Mistral-7B-Instruct-v0.2-GGUF',
    filename='mistral-7b-instruct-v0.2.Q4_K_M.gguf',
    local_dir='/root/models/mistral-gguf'
\"
"

# Luego inicia con GGUF
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/models \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model /models/mistral-gguf/mistral-7b-instruct-v0.2.Q4_K_M.gguf \
    --host 0.0.0.0 \\
    --port 2242 \
    --tokenizer mistralai/Mistral-7B-Instruct-v0.2
```

### 5. Verifica el servidor

```bash
# Ver registros
docker logs -f aphrodite

# Comprobación de salud
curl http://localhost:2242/health

# Lista los modelos cargados
curl http://localhost:2242/v1/models
```

### 6. Accede a través del proxy HTTP de CLORE.AI

El panel de pedidos de CLORE.AI proporciona una `http_pub` URL para el puerto 2242. Úsala en tus aplicaciones cliente:

```
https://<order-id>-2242.clore.ai/v1
```

***

## Ejemplos de uso

### Ejemplo 1: Chat compatible con OpenAI

```bash
curl http://localhost:2242/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [
      {"role": "system", "content": "Eres un escritor creativo especializado en fantasía."},
      {"role": "user", "content": "Comienza un cuento corto sobre un dragón que aprende a pintar."}
    ],
    "max_tokens": 500,
    "temperature": 0.9,
    "top_p": 0.95
  }'
```

### Ejemplo 2: Muestreo avanzado con Mirostat

Aphrodite admite muestreo Mirostat para un texto largo más coherente:

```bash
curl http://localhost:2242/v1/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "prompt": "Érase una vez en una ciudad cyberpunk,",
    "max_tokens": 400,
    "mirostat_mode": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1
  }'
```

### Ejemplo 3: API compatible con Kobold

Aphrodite incluye un endpoint compatible con Kobold para su uso con frontends basados en KoboldAI:

```bash
# Endpoint de generación de Kobold
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "La nave espacial entró en hiperespacio,",
    "max_length": 200,
    "temperature": 0.8,
    "top_p": 0.92,
    "rep_pen": 1.15
  }'
```

### Ejemplo 4: Cliente Python con muestreadores personalizados

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:2242/v1",
    api_key="none",
)

# Escritura creativa con muestreadores personalizados
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {
            "role": "user",
            "content": "Escribe un poema sobre el silencio entre las estrellas.",
        }
    ],
    max_tokens=300,
    temperature=1.1,
    top_p=0.95,
    frequency_penalty=0.3,
    presence_penalty=0.2,
)

print(response.choices[0].message.content)
```

### Ejemplo 5: Completaciones por lotes

```python
import requests

BASE_URL = "http://localhost:2242"

prompts = [
    "El antiguo mago abrió su tomo y",
    "En el callejón iluminado por neón, el detective notó",
    "La última IA de la Tierra le dijo al robot:",
]

for prompt in prompts:
    response = requests.post(
        f"{BASE_URL}/v1/completions",
        json={
            "model": "mistralai/Mistral-7B-Instruct-v0.3",
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.85,
            "top_k": 50,
            "top_p": 0.95,
            "repetition_penalty": 1.1,
        },
    )
    result = response.json()
    print(f"Prompt: {prompt}")
    print(f"Continuación: {result['choices'][0]['text']}\n")
```

***

## Configuración

### Parámetros clave de inicio

| Parámetro                  | Valor predeterminado | Descripción                                        |
| -------------------------- | -------------------- | -------------------------------------------------- |
| `--model`                  | obligatorio          | ID del modelo o ruta local                         |
| `--host`                   | `127.0.0.1`          | Dirección de enlace                                |
| `--port`                   | `2242`               | Puerto del servidor                                |
| `--dtype`                  | `auto`               | `float16`, `bfloat16`, `float32`                   |
| `--quantization`           | ninguno              | `awq`, `gptq`, `squeezellm`, `fp8`                 |
| `--max-model-len`          | máximo del modelo    | Sobrescribe la longitud máxima del contexto        |
| `--gpu-memory-utilization` | `0.90`               | fracción de memoria de GPU                         |
| `--tensor-parallel-size`   | `1`                  | Número de GPUs para paralelismo tensorial          |
| `--max-num-seqs`           | `256`                | Máximo de secuencias concurrentes                  |
| `--trust-remote-code`      | false                | Permitir código personalizado del modelo           |
| `--api-keys`               | ninguno              | Claves API separadas por comas para autenticación  |
| `--served-model-name`      | nombre del modelo    | Nombre personalizado para las respuestas de la API |

### Añadir autenticación con clave API

```bash
python3 -m aphrodite.endpoints.openai.api_server \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --host 0.0.0.0 \\
  --port 2242 \
  --api-keys "mysecretkey1,mysecretkey2"
```

Luego usa `Authorization: Bearer mysecretkey1` en las solicitudes.

### Carga de modelos locales

```bash
# Monta el directorio de tu modelo y haz referencia a él
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /path/to/your/model:/model \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model /model \
    --host 0.0.0.0 \\
    --port 2242
```

***

## Consejos de rendimiento

### 1. Elige la cuantización adecuada para tu GPU

| VRAM de GPU | Modelo 7B   | Modelo 13B         | Modelo 30B |
| ----------- | ----------- | ------------------ | ---------- |
| 6 GB        | GPTQ/AWQ Q4 | ❌                  | ❌          |
| 8 GB        | GPTQ Q4     | GPTQ Q4 (ajustado) | ❌          |
| 12 GB       | Float16     | GPTQ Q4            | ❌          |
| 16 GB       | Float16     | Float16            | GPTQ Q4    |
| 24 GB       | Float16     | Float16            | GPTQ Q4    |
| 48 GB       | Float16     | Float16            | Float16    |

### 2. Ajusta la utilización de memoria de la GPU

```bash
--gpu-memory-utilization 0.93  # Aprieta más la caché KV
```

Empieza con un valor bajo y aumenta si no obtienes errores de OOM.

### 3. Usa bfloat16 en GPUs Ampere+

```bash
--dtype bfloat16
```

Mejor estabilidad numérica que float16, misma velocidad.

### 4. Optimiza para roleplay/escritura creativa

Estos muestreadores funcionan bien para texto narrativo:

```json
{
  "temperature": 0.85,
  "top_p": 0.92,
  "top_k": 40,
  "repetition_penalty": 1.12,
  "mirostat_mode": 2,
  "mirostat_tau": 5.0
}
```

### 5. Consejos para GPUs Pascal (GTX 10xx)

Para GPUs Pascal, evita Flash Attention (no es compatible):

```bash
--dtype float16  # float32 si obtienes errores NaN
--max-model-len 2048  # Reduce el contexto para ahorrar memoria
```

***

## Solución de problemas

### Problema: "CUDA capability sm\_6x not supported"

Las GPUs Pascal requieren un tratamiento especial. Usa:

```bash
--dtype float16
```

Si sigue fallando, comprueba si la versión de la imagen admite Pascal:

```bash
docker pull alpindale/aphrodite-engine:v0.5.4  # Prueba una versión específica
```

### Problema: "out of memory" en GPUs pequeñas

```bash
--gpu-memory-utilization 0.85
--max-model-len 2048
--quantization gptq  # O awq
```

### Problema: generación lenta de tokens

* Comprueba que realmente se esté usando la GPU: `nvidia-smi` dentro del contenedor
* Activa tamaños de lote más grandes: `--max-num-seqs 64`
* Usa AWQ en lugar de GPTQ (inferencia más rápida)

### Problema: modelo no encontrado / errores 404

Comprueba siempre que el nombre de tu modelo coincida exactamente:

```bash
curl http://localhost:2242/v1/models
```

Usa el nombre exacto del modelo de la respuesta en tus solicitudes.

### Problema: salida repetitiva

Añade penalización por repetición:

```json
{
  "repetition_penalty": 1.15,
  "frequency_penalty": 0.3
}
```

### Problema: el contenedor Docker se cierra silenciosamente

```bash
docker logs aphrodite 2>&1 | tail -100
# Causas comunes: VRAM insuficiente, ruta del modelo inválida
```

***

## Enlaces

* [GitHub](https://github.com/PygmalionAI/aphrodite-engine)
* [Documentación](https://aphrodite.pygmalion.chat)
* [Docker Hub](https://hub.docker.com/r/alpindale/aphrodite-engine)
* [Modelos compatibles](https://github.com/PygmalionAI/aphrodite-engine?tab=readme-ov-file#supported-models)
* [Marketplace de CLORE.AI](https://clore.ai/marketplace)

***

## Recomendaciones de GPU para Clore.ai

| Caso de uso            | GPU recomendada  | Costo estimado en Clore.ai |
| ---------------------- | ---------------- | -------------------------- |
| Desarrollo/Pruebas     | RTX 3090 (24GB)  | $0.07–0.21/gpu/hr          |
| Producción (7B–13B)    | RTX 4090 (24GB)  | $0.14–0.42/gpu/hr          |
| Modelos grandes (70B+) | A100 80GB / H100 | \~$1.04/gpu/h              |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

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