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

# TGI (Text Generation Inference)

Text Generation Inference (TGI) est le framework de service de modèles de langage à l'échelle de production de HuggingFace, conçu pour des inférences à haut débit et à faible latence. Il prend en charge Flash Attention 2, le batching continu, PagedAttention et le parallélisme tensoriel dès la sortie de la boîte — en faisant la solution de référence pour déployer des grands modèles de langage à grande échelle sur les serveurs GPU CLORE.AI.

{% 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      | 8 Go                                                     | 24 Go+               |
| Disque    | 50 Go                                                    | 200 Go+              |
| GPU       | N'importe quel GPU NVIDIA (Ampere+ pour Flash Attention) | A100, H100, RTX 4090 |

{% hint style="info" %}
Flash Attention 2 nécessite une architecture Ampere ou plus récente (RTX 3000+, A100, H100). Pour les GPU plus anciens, TGI reviendra automatiquement à l'attention standard.
{% endhint %}

## Déploiement rapide sur CLORE.AI

**Image Docker :** `ghcr.io/huggingface/text-generation-inference:latest`

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

**Variables d’environnement :**

| Variable           | Exemple                              | Description                                   |
| ------------------ | ------------------------------------ | --------------------------------------------- |
| `MODEL_ID`         | `mistralai/Mistral-7B-Instruct-v0.3` | Identifiant de modèle HuggingFace             |
| `HF_TOKEN`         | `hf_xxx...`                          | Jeton HuggingFace (pour les modèles protégés) |
| `NUM_SHARD`        | `2`                                  | Nombre de GPU pour le parallélisme tensoriel  |
| `MAX_INPUT_LENGTH` | `4096`                               | Nombre maximal de tokens d'entrée             |
| `MAX_TOTAL_TOKENS` | `8192`                               | Nombre maximal de tokens entrée + sortie      |
| `QUANTIZE`         | `bitsandbytes-nf4`                   | Méthode de quantification                     |

## Configuration étape par étape

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

Aller à [CLORE.AI Marketplace](https://clore.ai/marketplace) et filtrer les serveurs par :

* VRAM ≥ 24 Go pour les modèles 7B (précision complète)
* VRAM ≥ 12 Go pour les modèles 7B (quantification 4 bits)
* VRAM ≥ 80 Go pour les modèles 70B (précision complète, GPU unique)

### 2. Se connecter via SSH

Après la confirmation de votre commande, connectez-vous à votre serveur en utilisant les détails SSH depuis votre tableau de bord CLORE.AI :

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

Ou utilisez le terminal web depuis le panneau de votre commande CLORE.AI.

### 3. Récupérer l'image Docker TGI

```bash
docker pull ghcr.io/huggingface/text-generation-inference:latest
```

### 4. Lancer TGI avec un modèle

**Lancement de base (Mistral 7B) :**

```bash
docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  -e MODEL_ID=mistralai/Mistral-7B-Instruct-v0.3 \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mistral-7B-Instruct-v0.3 \
  --max-input-length 4096 \
  --max-total-tokens 8192
```

**Avec le token HuggingFace (pour les modèles protégés comme Llama 3) :**

```bash
docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  -e HUGGING_FACE_HUB_TOKEN=hf_your_token_here \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Meta-Llama-3-8B-Instruct \
  --max-input-length 8192 \
  --max-total-tokens 16384
```

**Avec quantification 4 bits (pour une VRAM plus petite) :**

```bash
docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --quantize bitsandbytes-nf4 \
  --max-input-length 4096 \
  --max-total-tokens 8192
```

**Parallélisme tensoriel multi-GPU (pour les modèles 70B) :**

```bash
docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 2g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Meta-Llama-3-70B-Instruct \
  --num-shard 2 \
  --max-input-length 8192 \
  --max-total-tokens 16384
```

### 5. Vérifier que le serveur fonctionne

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

# Attendre le message "Connected", puis tester :
curl http://localhost:8080/health
```

Réponse attendue : `{"status":"ok"}`

### 6. Accéder via le proxy HTTP de CLORE.AI

Dans le panneau de votre commande CLORE.AI, vous verrez votre `http_pub` URL pour le port 8080. Cela permet l'accès via navigateur/API sans tunnel SSH :

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

***

## Exemples d’utilisation

### Exemple 1 : Génération de texte basique

```bash
curl http://localhost:8080/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": "Quelle est la capitale de la France ?",
    "parameters": {
      "max_new_tokens": 100,
      "temperature": 0.7
    }
  }'
```

### Exemple 2 : Complétions de chat (compatible OpenAI)

TGI prend en charge le format d'API de complétions de chat d'OpenAI :

```bash
curl http://localhost:8080/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "tgi",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Expliquez l'intrication quantique en termes simples."}
    ],
    "max_tokens": 512,
    "temperature": 0.8,
    "stream": false
  }'
```

### Exemple 3 : Réponse en streaming

```bash
curl http://localhost:8080/generate_stream \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": "Écrivez une fonction Python pour calculer les nombres de Fibonacci :",
    "parameters": {
      "max_new_tokens": 300,
      "temperature": 0.2
    }
  }' \
  --no-buffer
```

### Exemple 4 : Client Python

```python
from huggingface_hub import InferenceClient

# Remplacez par votre URL http_pub CLORE.AI
client = InferenceClient(model="http://localhost:8080")

# Génération simple
response = client.text_generation(
    "Traduire en français : Hello, how are you?",
    max_new_tokens=100,
    temperature=0.7,
)
print(response)

# Chat
for token in client.chat_completion(
    messages=[{"role": "user", "content": "Qu'est-ce que l'apprentissage automatique ?"}],
    max_tokens=200,
    stream=True,
):
    print(token.choices[0].delta.content, end="", flush=True)
```

### Exemple 5 : Requêtes par lot

```python
import requests

BASE_URL = "http://localhost:8080"  # ou votre URL http_pub CLORE.AI

prompts = [
    "Résumez la Révolution française en 3 phrases.",
    "Écrivez un haïku sur le calcul GPU.",
    "Quels sont les principaux avantages de Rust par rapport à C++ ?",
]

results = []
for prompt in prompts:
    response = requests.post(
        f"{BASE_URL}/generate",
        json={"inputs": prompt, "parameters": {"max_new_tokens": 150}},
    )
    results.append(response.json()["generated_text"])

for prompt, result in zip(prompts, results):
    print(f"Prompt: {prompt}\nAnswer: {result}\n{'-'*50}")
```

***

## Configuration

### Paramètres CLI clés

| Paramètre                   | Par défaut | Description                                        |
| --------------------------- | ---------- | -------------------------------------------------- |
| `--model-id`                | requis     | ID du modèle HuggingFace ou chemin local           |
| `--num-shard`               | 1          | Nombre de fragments GPU (parallélisme tensoriel)   |
| `--max-concurrent-requests` | 128        | Nombre maximum de requêtes simultanées             |
| `--max-input-length`        | 1024       | Longueur maximale des tokens d'entrée              |
| `--max-total-tokens`        | 2048       | Nombre maximal de tokens entrée + sortie           |
| `--max-batch-total-tokens`  | auto       | Nombre maximal de tokens par lot                   |
| `--quantize`                | aucune     | Quantification : `bitsandbytes-nf4`, `gptq`, `awq` |
| `--dtype`                   | auto       | `float16`, `bfloat16`                              |
| `--trust-remote-code`       | false      | Autoriser le code personnalisé du modèle           |
| `--port`                    | 80         | Port du serveur                                    |

### Utilisation d'un modèle local

Si vous avez un modèle téléchargé localement :

```bash
docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /path/to/your/model:/model \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id /model
```

### Quantification AWQ (plus rapide que NF4)

```bash
docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantize awq
```

***

## Conseils de performance

### 1. Activer Flash Attention 2

Flash Attention 2 est activé automatiquement sur les GPU Ampere+ (RTX 3000+, A100, H100). Aucune configuration supplémentaire requise.

### 2. Ajuster la taille maximale de lot

Pour des scénarios à haut débit, augmentez la taille de lot :

```bash
--max-batch-total-tokens 32000 \
--max-waiting-tokens 20
```

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

```bash
--dtype bfloat16
```

Ceci est plus stable numériquement que le float16 et offre des performances identiques sur les GPU modernes.

### 4. Pré-télécharger les modèles vers un stockage persistant

```bash
# Sur le serveur, pré-téléchargez avant de démarrer TGI
pip install huggingface_hub
python -c "
from huggingface_hub import snapshot_download
snapshot_download('mistralai/Mistral-7B-Instruct-v0.3', local_dir='/root/models/mistral-7b')
"
```

Ensuite, montez le chemin local pour éviter de retélécharger lors des redémarrages.

### 5. Gestion de la mémoire GPU

Pour RTX 3090/4090 (24 Go de VRAM) :

```bash
# Le modèle 7B en float16 tient parfaitement
--max-total-tokens 8192

# Le modèle 13B nécessite une quantification
--quantize bitsandbytes-nf4
--max-total-tokens 4096
```

### 6. Décodage spéculatif

Pour une génération plus rapide avec des modèles plus petits en tant que brouillon :

```bash
--speculate 4  # Nombre de tokens spéculatifs
```

***

## Dépannage

### Problème : "CUDA out of memory"

```
Erreur : CUDA out of memory. Tentative d'allouer X Gio
```

**Solution :** Réduire `--max-total-tokens` ou activer la quantification :

```bash
--quantize bitsandbytes-nf4
--max-total-tokens 4096
```

### Problème : le téléchargement du modèle est lent

**Solution :** Utilisez un miroir HuggingFace ou pré-téléchargez :

```bash
# Définir le miroir
-e HF_ENDPOINT=https://hf-mirror.com
```

### Problème : serveur inaccessible via http\_pub

**Solution :** Assurez-vous que le port 8080 est correctement mappé. TGI écoute sur le port 80 en interne, mais vous le mappez sur 8080 en externe :

```bash
-p 8080:80  # hôte:conteneur
```

### Problème : "trust\_remote\_code est requis"

Certains modèles (par ex., Falcon, Phi) nécessitent du code personnalisé :

```bash
--trust-remote-code
```

### Problème : première réponse lente

La première requête déclenche le chargement du modèle en VRAM. C'est normal. Les requêtes suivantes seront rapides.

```bash
# Vérifier la progression du chargement
docker logs -f tgi | grep -E "Connected|Error|Loading"
```

### Problème : le conteneur se ferme immédiatement

```bash
# Vérifier les erreurs
docker logs tgi

# Solution courante : augmenter la mémoire partagée
--shm-size 2g
```

***

## Liens

* [GitHub](https://github.com/huggingface/text-generation-inference)
* [Documentation](https://huggingface.co/docs/text-generation-inference)
* [Docker Hub / GHCR](https://github.com/huggingface/text-generation-inference/pkgs/container/text-generation-inference)
* [Modèles pris en charge](https://huggingface.co/docs/text-generation-inference/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/tgi.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.