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

Exécutez HuggingFace Text Generation Inference (TGI) pour la mise en service de LLM en production sur les GPU Clore.ai

Text Generation Inference (TGI) est le framework de diffusion de LLM prêt pour la production de HuggingFace, conçu pour une inférence à haut débit et à faible latence. Il prend en charge Flash Attention 2, le batching continu, PagedAttention et le parallélisme tensoriel dès le départ — ce qui en fait 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 [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

| Paramètre | Minimum                                    | Recommandé           |
| --------- | ------------------------------------------ | -------------------- |
| RAM       | 16 Go                                      | 32 Go+               |
| VRAM      | 8 Go                                       | 24 Go+               |
| Disque    | 50 Go                                      | 200 Go+              |
| GPU       | Tout 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 basculera automatiquement vers 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` | ID du modèle HuggingFace                               |
| `HF_TOKEN`         | `hf_xxx...`                          | Jeton HuggingFace (pour les modèles à accès restreint) |
| `NUM_SHARD`        | `2`                                  | Nombre de GPU pour le parallélisme tensoriel           |
| `MAX_INPUT_LENGTH` | `4096`                               | Nombre maximal de tokens en entrée                     |
| `MAX_TOTAL_TOKENS` | `8192`                               | Nombre maximal de tokens d'entrée + de sortie          |
| `QUANTIZE`         | `bitsandbytes-nf4`                   | Méthode de quantification                              |

## Configuration étape par étape

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

Accédez à [la place de marché CLORE.AI](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

Une fois votre commande confirmée, connectez-vous à votre serveur en utilisant les détails SSH de votre tableau de bord CLORE.AI :

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

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

### 3. Télécharger 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 un jeton HuggingFace (pour les modèles à accès restreint 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 faible) :**

```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 journaux
docker logs -f tgi

# Attendez le message "Connected", puis testez :
curl http://localhost:8080/health
```

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

### 6. Accédez via le proxy HTTP CLORE.AI

Dans votre panneau de 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 simple

```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 API de complétions de chat OpenAI :

```bash
curl http://localhost:8080/v1/chat/completions \\
  -X POST \
  -H 'Content-Type: application/json' \\
  -d '{
    "model": "tgi",
    "messages": [
      {"role": "system", "content": "Vous êtes un assistant utile."},
      {"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 CLORE.AI http_pub
client = InferenceClient(model="http://localhost:8080")

# Génération simple
response = client.text_generation(
    "Traduisez en français : Bonjour, comment allez-vous ?",
    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 lots

```python
import requests

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

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}\nRéponse : {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 shards GPU (parallélisme tensoriel)      |
| `--max-concurrent-requests` | 128        | Nombre maximal de requêtes simultanées             |
| `--max-input-length`        | 1024       | Longueur maximale des tokens d'entrée              |
| `--max-total-tokens`        | 2048       | Nombre maximal de tokens d'entrée + de sortie      |
| `--max-batch-total-tokens`  | auto       | Nombre maximal de tokens par lot                   |
| `--quantize`                | aucun      | 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 téléchargé un modèle 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 automatiquement activé sur les GPU Ampere+ (RTX 3000+, A100, H100). Aucune configuration supplémentaire n'est nécessaire.

### 2. Ajuster la taille maximale des lots

Pour les scénarios à haut débit, augmentez la taille du lot :

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

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

```bash
--dtype bfloat16
```

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

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

```bash
# Sur le serveur, pré-téléchargez avant de lancer 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')
"
```

Montez ensuite le chemin local pour éviter un nouveau téléchargement 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 de plus petits modèles comme brouillon :

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

***

## Dépannage

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

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

**Solution :** Réduisez `--max-total-tokens` ou activez 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 is required"

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 dans la 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

# Correctif courant : 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)
* [la place de marché CLORE.AI](https://clore.ai/marketplace)

***

## Recommandations GPU Clore.ai

| Cas d’utilisation     | GPU recommandé    | Coût estimé sur Clore.ai |
| --------------------- | ----------------- | ------------------------ |
| Développement/Test    | RTX 3090 (24 Go)  | 0,07–0,21 $/gpu/h        |
| Production (7B–13B)   | RTX 4090 (24 Go)  | 0,14–0,42 $/gpu/h        |
| Grands modèles (70B+) | A100 80 Go / H100 | \~1,04 $/GPU/heure       |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

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