> 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/text-generation-webui.md).

# Text Generation WebUI

Exécutez text-generation-webui pour l'inférence LLM sur les GPU Clore.ai

Exécutez l’interface LLM la plus populaire avec prise en charge de tous les formats de modèles.

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

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<proxy-address>`

## Pourquoi Text Generation WebUI ?

* Prend en charge les formats GGUF, GPTQ, AWQ, EXL2, HF
* Modes chat, notebook et API intégrés
* Extensions : voix, personnages, multimodal
* Prise en charge du fine-tuning
* Changement de modèle à la volée

## Exigences

| Taille du modèle | VRAM minimale | Recommandé |
| ---------------- | ------------- | ---------- |
| 7B (Q4)          | 6 Go          | RTX 3060   |
| 13B (Q4)         | 10GB          | RTX 3080   |
| 30B (Q4)         | 20 Go         | RTX 4090   |
| 70B (Q4)         | 40 Go         | A100       |

## Déploiement rapide

**Image Docker :**

```
atinoda/text-generation-webui:default-nvidia
```

**Ports :**

```
22/tcp
7860/http
5000/http
5005/http
```

**Environnement :**

```
EXTRA_LAUNCH_ARGS=--listen --api
```

## Installation manuelle

**Image :**

```
nvidia/cuda:12.8.1-devel-ubuntu22.04
```

**Ports :**

```
22/tcp
7860/http
5000/http
```

**Commande :**

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

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Accéder à l’interface WebUI

1. Attendez le déploiement
2. Trouvez le mappage du port 7860 dans **Mes commandes**
3. Ouvrir : `http://<proxy>:<port>`

## Télécharger les modèles

### Depuis HuggingFace (dans WebUI)

1. Accédez à **Modèle** onglet
2. Entrez le nom du modèle : `bartowski/Meta-Llama-3.1-8B-Instruct-GGUF`
3. Cliquez sur **Télécharger**

### Via la ligne de commande

```bash
cd /workspace/text-generation-webui

# Télécharger le modèle GGUF
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Télécharger un fichier spécifique
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF --specific-file Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf
```

### Modèles recommandés

**Pour le chat :**

```bash

# Llama 2 Chat (7B, rapide)
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Mistral Instruct (excellent)
python download-model.py bartowski/Mistral-7B-Instruct-v0.3-GGUF

# OpenHermes (excellent modèle polyvalent)
python download-model.py bartowski/OpenHermes-2.5-Mistral-7B-GGUF
```

**Pour le codage :**

```bash

# CodeLlama
python download-model.py bartowski/CodeLlama-13B-Instruct-GGUF

# DeepSeek Coder
python download-model.py bartowski/DeepSeek-Coder-V2-Lite-Instruct-GGUF
```

**Pour le jeu de rôle :**

```bash

# MythoMax
python download-model.py bartowski/MythoMax-L2-13B-GGUF
```

## Chargement des modèles

### GGUF (recommandé pour la plupart des utilisateurs)

1. **Modèle** onglet → Sélectionnez le dossier du modèle
2. **Chargeur de modèle :** llama.cpp
3. Définissez **n-gpu-layers :**
   * RTX 3090 : 35-40
   * RTX 4090 : 45-50
   * A100 : 80+
4. Cliquez sur **Charger**

### GPTQ (rapide, quantifié)

1. Télécharger le modèle GPTQ
2. **Chargeur de modèle :** ExLlama\_HF ou AutoGPTQ
3. Charger le modèle

### EXL2 (meilleure vitesse)

```bash

# Installer exllamav2
pip install exllamav2
```

1. Télécharger le modèle EXL2
2. **Chargeur de modèle :** ExLlamav2\_HF
3. Charger

## Configuration du chat

### Configuration du personnage

1. Accédez à **Paramètres** → **Personnage**
2. Créer ou charger une carte de personnage
3. Définir :
   * Nom
   * Contexte/persona
   * Dialogue d'exemple

### Mode Instruct

Pour les modèles ajustés pour les instructions :

1. **Paramètres** → **Modèle d'instructions**
2. Sélectionnez le modèle correspondant à votre modèle :
   * Llama-2-chat
   * Mistral
   * ChatML
   * Alpaca

## Utilisation de l’API

### Activer l'API

Commencez avec `--api` option (port par défaut 5000)

### API compatible avec 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 native

```python
import requests

response = requests.post(
    "http://localhost:5000/api/v1/generate",
    json={
        "prompt": "Write a story about",
        "max_new_tokens": 200,
        "temperature": 0.7
    }
)
print(response.json()["results"][0]["text"])
```

## Extensions

### Installation des extensions

```bash
cd /workspace/text-generation-webui/extensions

# Silero TTS (voix)
git clone https://github.com/oobabooga/text-generation-webui-extensions

# SuperBoogav2 (RAG/mémoire à long terme)

# Déjà inclus, activez-le dans l’interface
```

### Activer les extensions

1. **Session** onglet → **Extensions**
2. Cochez les cases des extensions souhaitées
3. Cliquez sur **Appliquer et redémarrer**

### Extensions populaires

| Extension         | Objectif                         |
| ----------------- | -------------------------------- |
| silero\_tts       | Sortie vocale                    |
| whisper\_stt      | Entrée vocale                    |
| superbooga        | Questions-réponses sur documents |
| sd\_api\_pictures | Génération d'images              |
| multimodal        | Compréhension d'image            |

## Optimisation des performances

### Paramètres GGUF

```
n_gpu_layers: 35    # Couches GPU (plus = plus rapide)
n_ctx: 4096         # Longueur du contexte
n_batch: 512        # Taille du lot
threads: 8          # Threads CPU
```

### Optimisation de la mémoire

Pour une VRAM limitée :

```bash
python server.py --listen --n-gpu-layers 20 --no-mmap
```

### Optimisation de la vitesse

```bash

# Utiliser llama.cpp avec cuBLAS
python server.py --listen --loader llama.cpp --n-gpu-layers 50 --threads 8
```

## Ajustement fin (LoRA)

### Onglet d'entraînement

1. Accédez à **Entraînement** onglet
2. Charger le modèle de base
3. Importer le jeu de données (format JSON)
4. Configurer :
   * Rang LoRA : 8-32
   * Taux d'apprentissage : 1e-4
   * Époques : 3-5
5. Lancez l’entraînement

### Format du jeu de données

```json
[
  {"instruction": "Résumez ceci :", "input": "Long texte...", "output": "Résumé..."},
  {"instruction": "Traduire en français :", "input": "Hello", "output": "Bonjour"}
]
```

## Sauvegarder votre travail

```bash

# Sauvegarder les modèles
rsync -avz /workspace/text-generation-webui/models/ backup-server:/models/

# Sauvegarder les personnages
rsync -avz /workspace/text-generation-webui/characters/ backup-server:/characters/

# Sauvegarder les LoRA
rsync -avz /workspace/text-generation-webui/loras/ backup-server:/loras/
```

## Dépannage

### Le modèle ne se charge pas

* Vérifiez l'utilisation de la VRAM : `nvidia-smi`
* Réduisez `n_gpu_layers`
* Utilisez une quantification plus petite (Q4\_K\_M → Q4\_K\_S)

### Génération lente

* Augmentez `n_gpu_layers`
* Utilisez EXL2 au lieu de GGUF
* Activer `--no-mmap`

{% hint style="danger" %}
**Mémoire insuffisante**
{% endhint %}

pendant la génération - Réduisez \`n\_ctx\` (longueur du contexte) - Utilisez \`--n-gpu-layers 0\` pour un usage CPU uniquement - Essayez un modèle plus petit

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

| GPU        | Tarif horaire | Tarif journalier | Session de 4 heures |
| ---------- | ------------- | ---------------- | ------------------- |
| 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 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs


---

# 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-fr/modeles-de-langage/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.