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

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À 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@<adresse-proxy>`

## Pourquoi Text Generation WebUI ?

* Prend en charge les formats GGUF, GPTQ, AWQ, EXL2, HF
* Modes chat, carnet 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 min | Recommandé |
| ---------------- | -------- | ---------- |
| 7B (Q4)          | 6 Go     | RTX 3060   |
| 13B (Q4)         | 10Go     | RTX 3080   |
| 30B (Q4)         | 20Go     | RTX 4090   |
| 70B (Q4)         | 40Go     | 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.1.0-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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

## Accéder à WebUI

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

## Télécharger des modèles

### Depuis HuggingFace (dans WebUI)

1. Aller à la **Modèle** onglet
2. Saisir le nom du modèle : `bartowski/Meta-Llama-3.1-8B-Instruct-GGUF`
3. Cliquez **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 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électionner le dossier du modèle
2. **Chargeur de modèle :** llama.cpp
3. Définir **n-gpu-layers :**
   * RTX 3090 : 35-40
   * RTX 4090 : 45-50
   * A100 : 80+
4. Cliquez **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. Aller à la **Paramètres** → **Personnage**
2. Créer ou charger une fiche de personnage
3. Définir :
   * Nom
   * Contexte/persona
   * Dialogue exemple

### Mode Instruct

Pour les modèles ajustés par instruction :

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

## Utilisation de l'API

### Activer l'API

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

### API compatible 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": "Bonjour !"}]
)
print(response.choices[0].message.content)
```

### API native

```python
import requests

response = requests.post(
    "http://localhost:5000/api/v1/generate",
    json={
        "prompt": "Écrire une histoire sur",
        "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, activer dans l'UI
```

### Activer les extensions

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

### Extensions populaires

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

## Réglage 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
```

## Fine-tuning (LoRA)

### Onglet d'entraînement

1. Aller à la **Entraînement** onglet
2. Charger le modèle de base
3. Téléverser le jeu de données (format JSON)
4. Configurer :
   * Rang LoRA : 8-32
   * Taux d'apprentissage : 1e-4
   * Époques : 3-5
5. Démarrer l'entraînement

### Format du jeu de données

```json
[
  {"instruction": "Résumé :", "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érifier l'utilisation de la VRAM : `nvidia-smi`
* Réduire `n_gpu_layers`
* Utiliser une quantification plus petite (Q4\_K\_M → Q4\_K\_S)

### Génération lente

* Augmentez `n_gpu_layers`
* Utiliser EXL2 au lieu de GGUF
* Activez `--no-mmap`

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

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

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 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 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer 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:

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