# Motor Aphrodite

Aphrodite Engine es un servidor de inferencia LLM optimizado construido sobre vLLM, específicamente diseñado para la comunidad de escritura creativa y roleplay. Admite una amplia gama de GPU a partir de 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 más comunes.

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

## 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 soporta GPU de la generación Pascal (serie GTX 10xx). Esto lo hace ideal para servidores económicos en CLORE.AI con GPUs antiguas que tienen precios de alquiler bajos.
{% endhint %}

## Despliegue rápido en CLORE.AI

**Imagen 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

El amplio soporte de GPU de Aphrodite te permite conseguir servidores económicos en [CLORE.AI Marketplace](https://clore.ai/marketplace):

* **Pascal (GTX 1060–1080 Ti)**: 6–11 GB de VRAM — ejecutar 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, a toda velocidad
* **Ada (serie RTX 4000)**: 16–24 GB de VRAM — mejor relación rendimiento/costo

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

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

### 3. Descargar la imagen de Aphrodite Engine

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

### 4. Lanzar Aphrodite Engine

**Lanzamiento 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 soporta 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 lanza 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. Verifique el Servidor

```bash
# Comprobar logs
docker logs -f aphrodite

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

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

### 6. Acceso vía Proxy HTTP de CLORE.AI

El panel de pedidos de CLORE.AI proporciona un `http_pub` URL para el puerto 2242. Úsalo 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 ficción fantástica."},
      {"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 soporta muestreo Mirostat para textos largos más coherentes:

```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 usar con frontends basados en KoboldAI:

```bash
# Endpoint de generación Kobold
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "La nave espacial entró en el 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 a medida
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 en 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 lanzamiento

| Parámetro                  | Por defecto       | Descripción                                        |
| -------------------------- | ----------------- | -------------------------------------------------- |
| `--model`                  | requerido         | 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`           | ninguna           | `awq`, `gptq`, `squeezellm`, `fp8`                 |
| `--max-model-len`          | máx. del modelo   | Anular la longitud máxima del contexto             |
| `--gpu-memory-utilization` | `0.90`            | Fracción de memoria 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 de modelo personalizado            |
| `--api-keys`               | ninguna           | Claves API separadas por comas para autenticación  |
| `--served-model-name`      | nombre del modelo | Nombre personalizado para las respuestas de la API |

### Añadiendo autenticación por 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 use `Authorization: Bearer mysecretkey1` en las solicitudes.

### Cargando modelos locales

```bash
# Monta tu directorio de modelos y refiérelo
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 GPU | Modelo 7B   | Modelo 13B         | Modelo 30B |
| -------- | ----------- | ------------------ | ---------- |
| 6 GB     | GPTQ/AWQ Q4 | ❌                  | ❌          |
| 8 GB     | GPTQ Q4     | GPTQ Q4 (apretado) | ❌          |
| 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 GPU

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

Comienza más bajo y aumenta si no obtienes errores OOM.

### 3. Usar bfloat16 en GPUs Ampere+

```bash
--dtype bfloat16
```

Mejor estabilidad numérica que float16, misma velocidad.

### 4. Optimizar 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 GPU Pascal (GTX 10xx)

Para GPUs Pascal, evita Flash Attention (no soportado):

```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 tratamiento especial. Usa:

```bash
--dtype float16
```

Si aún falla, 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: "fuera de memoria" en GPUs pequeñas

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

### Problema: Generación de tokens lenta

* Comprueba que la GPU esté siendo usada realmente: `nvidia-smi` dentro del contenedor
* Habilita tamaños de lote mayores: `--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 del 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 sale silenciosamente

```bash
docker logs aphrodite 2>&1 | tail -100
# Causas comunes: VRAM insuficiente, ruta de 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)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso            | GPU recomendada  | Coste estimado en Clore.ai |
| ---------------------- | ---------------- | -------------------------- |
| Desarrollo/Pruebas     | RTX 3090 (24GB)  | \~$0.12/gpu/hr             |
| Producción (7B–13B)    | RTX 4090 (24GB)  | \~$0.70/gpu/hr             |
| Modelos grandes (70B+) | A100 80GB / H100 | \~$1.20/gpu/hr             |

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


---

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