> 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-fr/modeles-de-langage/aphrodite-engine.md).

# Aphrodite Engine

Aphrodite Engine est un serveur d'inférence LLM optimisé construit sur vLLM, spécialement adapté à la communauté de l'écriture créative et du jeu de rôle. Il prend en charge un large éventail de GPU à partir de Pascal (série GTX 1000), ce qui en fait le choix parfait pour exécuter des modèles de langage sur des serveurs GPU CLORE.AI anciens ou économiques où d'autres frameworks échouent. Aphrodite ajoute des API compatibles Kobold, l'échantillonnage Mirostat et des algorithmes d'échantillonnage de texte avancés non présents dans les frameworks de service grand public.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Exigences serveur

| Paramètre | Minimum                    | Recommandé     |
| --------- | -------------------------- | -------------- |
| RAM       | 16 Go                      | 32 Go+         |
| VRAM      | 6 Go                       | 16 Go+         |
| Disque    | 40 Go                      | 150 Go+        |
| GPU       | NVIDIA Pascal+ (GTX 1060+) | RTX 3090, A100 |

{% hint style="info" %}
Aphrodite Engine est l'un des rares serveurs LLM à prendre en charge les GPU de génération Pascal (série GTX 10xx). Cela le rend idéal pour les serveurs économiques sur CLORE.AI avec des GPU plus anciens dont les tarifs de location sont bas.
{% endhint %}

## Déploiement rapide sur CLORE.AI

**Image Docker :** `alpindale/aphrodite-engine:latest`

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

**Variables d’environnement :**

| Variable          | Exemple                              | Description                                 |
| ----------------- | ------------------------------------ | ------------------------------------------- |
| `HF_TOKEN`        | `hf_xxx...`                          | Jeton HuggingFace pour les modèles protégés |
| `APHRODITE_MODEL` | `mistralai/Mistral-7B-Instruct-v0.3` | Modèle à charger                            |

## Configuration étape par étape

### 1. Louez un serveur GPU sur CLORE.AI

La large compatibilité GPU d'Aphrodite vous permet de trouver des serveurs économiques sur [CLORE.AI Marketplace](https://clore.ai/marketplace):

* **Pascal (GTX 1060–1080 Ti)**: 6–11 Go de VRAM — exécutez de petits modèles 3B–7B avec quantification
* **Turing (série RTX 2000)**: 8–24 Go de VRAM — modèles 7B–13B, meilleures performances
* **Ampere (RTX 3000/A100)**: 24–80 Go de VRAM — modèles 30B–70B, pleine vitesse
* **Ada (série RTX 4000)**: 16–24 Go de VRAM — meilleur rapport performance/coût

### 2. Se connecter via SSH

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

### 3. Récupérer l'image Aphrodite Engine

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

### 4. Lancer Aphrodite Engine

**Lancement basique avec un modèle 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
```

**Avec un token 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
```

**Avec quantification GPTQ (pour VRAM limitée) :**

```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
```

**Avec quantification 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
```

**Exécution d'un modèle GGUF (Aphrodite prend en charge GGUF nativement) :**

```bash
# D'abord téléchargez le fichier 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'
)\"
"

# Puis lancez avec 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. Vérifiez le serveur

```bash
# Vérifier les logs
docker logs -f aphrodite

# Vérification de l'état
curl http://localhost:2242/health

# Lister les modèles chargés
curl http://localhost:2242/v1/models
```

### 6. Accès via le proxy HTTP de CLORE.AI

Le panneau de commande de commande CLORE.AI fournit une `http_pub` URL pour le port 2242. Utilisez-la dans vos applications clientes :

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

***

## Exemples d’utilisation

### Exemple 1 : Chat compatible 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": "Vous êtes un écrivain créatif spécialisé dans la fiction fantastique."},
      {"role": "user", "content": "Commencez une courte histoire sur un dragon qui apprend à peindre."}
    ],
    "max_tokens": 500,
    "temperature": 0.9,
    "top_p": 0.95
  }'
```

### Exemple 2 : Échantillonnage avancé avec Mirostat

Aphrodite prend en charge l'échantillonnage Mirostat pour des textes longs plus cohérents :

```bash
curl http://localhost:2242/v1/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "prompt": "Il était une fois dans une ville cyberpunk,",
    "max_tokens": 400,
    "mirostat_mode": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1
  }'
```

### Exemple 3 : API compatible Kobold

Aphrodite inclut un endpoint compatible Kobold pour une utilisation avec des frontends basés sur KoboldAI :

```bash
# Endpoint de génération Kobold
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "Le vaisseau spatial entra en hyperespace,",
    "max_length": 200,
    "temperature": 0.8,
    "top_p": 0.92,
    "rep_pen": 1.15
  }'
```

### Exemple 4 : Client Python avec échantillonneurs personnalisés

```python
from openai import OpenAI

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

# Écriture créative avec des échantillonneurs adaptés
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {
            "role": "user",
            "content": "Écrivez un poème sur le silence entre les étoiles.",
        }
    ],
    max_tokens=300,
    temperature=1.1,
    top_p=0.95,
    frequency_penalty=0.3,
    presence_penalty=0.2,
)

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

### Exemple 5 : Complétions par lots

```python
import requests

BASE_URL = "http://localhost:2242"

prompts = [
    "Le vieux magicien ouvrit son grimoire et",
    "Dans la ruelle éclairée au néon, le détective remarqua",
    "La dernière IA sur Terre dit au 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"Continuation: {result['choices'][0]['text']}\n")
```

***

## Configuration

### Principaux paramètres de lancement

| Paramètre                  | Par défaut    | Description                                                |
| -------------------------- | ------------- | ---------------------------------------------------------- |
| `--model`                  | requis        | ID du modèle ou chemin local                               |
| `--host`                   | `127.0.0.1`   | Adresse de liaison                                         |
| `--port`                   | `2242`        | Port du serveur                                            |
| `--dtype`                  | `auto`        | `float16`, `bfloat16`, `float32`                           |
| `--quantization`           | aucune        | `awq`, `gptq`, `squeezellm`, `fp8`                         |
| `--max-model-len`          | max du modèle | Remplacer la longueur maximale du contexte                 |
| `--gpu-memory-utilization` | `0.90`        | Fraction de mémoire GPU                                    |
| `--tensor-parallel-size`   | `1`           | Nombre de GPU pour le parallélisme tensoriel               |
| `--max-num-seqs`           | `256`         | Nombre maximal de séquences simultanées                    |
| `--trust-remote-code`      | false         | Autoriser le code personnalisé du modèle                   |
| `--api-keys`               | aucune        | Clés API séparées par des virgules pour l'authentification |
| `--served-model-name`      | nom du modèle | Nom personnalisé pour les réponses de l'API                |

### Ajout de l'authentification par clé 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"
```

Puis utilisez `Authorization: Bearer mysecretkey1` dans les requêtes.

### Chargement de modèles locaux

```bash
# Montez votre répertoire de modèles et référencez-le
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
```

***

## Conseils de performance

### 1. Choisissez la bonne quantification pour votre GPU

| VRAM GPU | Modèle 7B   | Modèle 13B      | Modèle 30B |
| -------- | ----------- | --------------- | ---------- |
| 6 Go     | GPTQ/AWQ Q4 | ❌               | ❌          |
| 8 Go     | GPTQ Q4     | GPTQ Q4 (serré) | ❌          |
| 12 Go    | Float16     | GPTQ Q4         | ❌          |
| 16 Go    | Float16     | Float16         | GPTQ Q4    |
| 24 Go    | Float16     | Float16         | GPTQ Q4    |
| 48 GB    | Float16     | Float16         | Float16    |

### 2. Ajustez l'utilisation de la mémoire GPU

```bash
--gpu-memory-utilization 0.93  # Serrer davantage le cache KV
```

Commencez plus bas et augmentez si vous n'obtenez pas d'erreurs OOM.

### 3. Utiliser bfloat16 sur les GPU Ampere+

```bash
--dtype bfloat16
```

Meilleure stabilité numérique que le float16, même vitesse.

### 4. Optimiser pour le jeu de rôle / l'écriture créative

Ces échantillonneurs fonctionnent bien pour le texte narratif :

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

### 5. Conseils pour GPU Pascal (GTX 10xx)

Pour les GPU Pascal, évitez Flash Attention (non pris en charge) :

```bash
--dtype float16  # float32 si vous obtenez des erreurs NaN
--max-model-len 2048  # Réduire le contexte pour économiser la mémoire
```

***

## Dépannage

### Problème : "capacité CUDA sm\_6x non prise en charge"

Les GPU Pascal nécessitent un traitement spécial. Utilisez :

```bash
--dtype float16
```

Si cela échoue toujours, vérifiez si la version de l'image prend en charge Pascal :

```bash
docker pull alpindale/aphrodite-engine:v0.5.4  # Essayez une version spécifique
```

### Problème : "mémoire insuffisante" sur les petits GPU

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

### Problème : génération de tokens lente

* Vérifiez que le GPU est réellement utilisé : `nvidia-smi` à l'intérieur du conteneur
* Activez des tailles de lots plus grandes : `--max-num-seqs 64`
* Utilisez AWQ au lieu de GPTQ (inférence plus rapide)

### Problème : modèle introuvable / erreurs 404

Vérifiez toujours que le nom de votre modèle correspond exactement :

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

Utilisez le nom exact du modèle à partir de la réponse dans vos requêtes.

### Problème : sortie répétitive

Ajoutez une pénalité de répétition :

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

### Problème : le conteneur Docker se termine silencieusement

```bash
docker logs aphrodite 2>&1 | tail -100
# Causes courantes : VRAM insuffisante, chemin de modèle invalide
```

***

## Liens

* [GitHub](https://github.com/PygmalionAI/aphrodite-engine)
* [Documentation](https://aphrodite.pygmalion.chat)
* [Docker Hub](https://hub.docker.com/r/alpindale/aphrodite-engine)
* [Modèles pris en charge](https://github.com/PygmalionAI/aphrodite-engine?tab=readme-ov-file#supported-models)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)

***

## Recommandations GPU Clore.ai

| Cas d’utilisation     | GPU recommandé   | Coût estimé sur Clore.ai |
| --------------------- | ---------------- | ------------------------ |
| Développement/Test    | RTX 3090 (24GB)  | \~$0.12/gpu/hr           |
| Production (7B–13B)   | RTX 4090 (24GB)  | \~$0.70/gpu/hr           |
| Grands modèles (70B+) | A100 80GB / H100 | \~$1.20/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/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.