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

# SGLang

Déployez SGLang pour la mise en service LLM haute performance avec RadixAttention sur les GPU Clore.ai

SGLang (Structured Generation Language) est un framework haute performance de service de LLM développé par l'équipe LMSYS, connue pour son travail sur Vicuna et Chatbot Arena. Il intègre RadixAttention pour le partage du cache KV, une prise en charge efficace de MoE (Mixture of Experts) et une API compatible avec OpenAI — ce qui en fait l'un des moteurs d'inférence open source les plus rapides disponibles sur les serveurs GPU de 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       | NVIDIA Turing+ (RTX 2000+) | A100, H100, RTX 4090 |

{% hint style="info" %}
SGLang obtient les meilleures performances sur les GPU Ampere+ avec FlashInfer activé. Pour les modèles MoE comme Mixtral ou DeepSeek, des configurations multi-GPU sont recommandées.
{% endhint %}

## Déploiement rapide sur CLORE.AI

**Image Docker :** `lmsysorg/sglang:latest`

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

**Variables d'environnement :**

| Variable               | Exemple     | Description                                 |
| ---------------------- | ----------- | ------------------------------------------- |
| `HF_TOKEN`             | `hf_xxx...` | Jeton HuggingFace pour les modèles protégés |
| `CUDA_VISIBLE_DEVICES` | `0,1`       | GPU à utiliser                              |

## Configuration étape par étape

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

Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace) et sélectionnez un serveur :

* **Modèles 7B**: 16 Go de VRAM minimum (RTX 4080, A10)
* **Modèles 13B**: 24 Go de VRAM (RTX 3090, RTX 4090, A5000)
* **Modèles 70B**: 80 Go+ de VRAM (A100 80 Go) ou multi-GPU
* **Modèles MoE (Mixtral 8x7B)**: 48 Go de VRAM ou 2× 24 Go

### 2. Connectez-vous en SSH à votre serveur

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

### 3. Téléchargez l'image Docker de SGLang

```bash
docker pull lmsysorg/sglang:latest
```

### 4. Lancez le serveur SGLang

**Lancement de base (Llama 3.1 8B) :**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000
```

**Avec un jeton HuggingFace :**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your_token_here \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --dtype bfloat16
```

**Qwen2.5 72B sur multi-GPU :**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --tp 2 \
    --dtype bfloat16
```

**DeepSeek-V2 (modèle MoE) :**

```bash
docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path deepseek-ai/DeepSeek-V2-Lite-Chat \
    --host 0.0.0.0 \
    --port 30000 \
    --trust-remote-code \
    --tp 1
```

### 5. Vérifiez l'état du serveur

```bash
# Voir les logs
docker logs -f sglang

# Vérification de l'état (attendre environ 2 à 3 minutes pour le chargement du modèle)
curl http://localhost:30000/health

# Obtenir les informations du modèle
curl http://localhost:30000/get_model_info
```

### 6. Accédez depuis l'extérieur via le proxy CLORE.AI

Votre tableau de bord CLORE.AI fournit une `http_pub` URL pour le port 30000 :

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

Utilisez cette URL comme URL de base dans n'importe quel client compatible OpenAI.

***

## Exemples d'utilisation

### Exemple 1 : complétions de chat compatibles OpenAI

```bash
curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "You are a helpful coding assistant."},
      {"role": "user", "content": "Write a quicksort implementation in Python."}
    ],
    "max_tokens": 512,
    "temperature": 0.2
  }'
```

### Exemple 2 : réponse en streaming

```bash
curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Explain how transformer attention works."}
    ],
    "max_tokens": 800,
    "stream": true
  }' \
  --no-buffer
```

### Exemple 3 : client Python OpenAI

```python
from openai import OpenAI

# Pointe vers votre serveur SGLang CLORE.AI
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang ne nécessite pas d'authentification par défaut
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "You are a data science expert."},
        {"role": "user", "content": "What is gradient boosting?"},
    ],
    max_tokens=400,
    temperature=0.7,
)

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

### Exemple 4 : inférence par lot avec l'API native SGLang

L'API native de SGLang offre un contrôle supplémentaire :

```python
import requests

# Générer des complétions
response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "L'avenir de l'IA est",
        "sampling_params": {
            "max_new_tokens": 200,
            "temperature": 0.8,
            "top_p": 0.95,
        },
    },
)
print(response.json()["text"])
```

### Exemple 5 : sortie JSON contrainte

SGLang prend en charge la génération de sorties structurées :

```python
import requests

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "city": {"type": "string"},
    },
    "required": ["name", "age", "city"],
}

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Extraire les informations : John Smith, 35 ans, vit à New York.",
        "sampling_params": {
            "max_new_tokens": 100,
            "temperature": 0.0,
        },
        "json_schema": schema,
    },
)
print(response.json()["text"])
# Sortie : {"name": "John Smith", "age": 35, "city": "New York"}
```

***

## Configuration

### Paramètres de lancement clés

| Paramètre               | Par défaut          | Description                                               |
| ----------------------- | ------------------- | --------------------------------------------------------- |
| `--model-path`          | requis              | ID de modèle HuggingFace ou chemin local                  |
| `--host`                | `127.0.0.1`         | Hôte de liaison (utiliser `0.0.0.0` pour l'externe)       |
| `--port`                | `30000`             | Port du serveur                                           |
| `--tp`                  | `1`                 | Degré de parallélisme tensoriel (nb de GPU)               |
| `--dp`                  | `1`                 | Degré de parallélisme des données                         |
| `--dtype`               | `auto`              | `float16`, `bfloat16`, `float32`                          |
| `--mem-fraction-static` | `0.88`              | Fraction de la VRAM pour le cache KV                      |
| `--max-prefill-tokens`  | auto                | Nombre max de jetons en une seule étape de préremplissage |
| `--context-length`      | max du modèle       | Remplacer la longueur maximale du contexte                |
| `--trust-remote-code`   | false               | Autoriser le code personnalisé du modèle                  |
| `--quantization`        | none                | `awq`, `gptq`, `fp8`                                      |
| `--load-format`         | `auto`              | `auto`, `pt`, `safetensors`                               |
| `--tokenizer-path`      | identique au modèle | Chemin personnalisé du tokenizer                          |

### Options de quantification

**AWQ (recommandé pour la vitesse) :**

```bash
python3 -m sglang.launch_server \
  --model-path casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantization awq \
  --host 0.0.0.0 \
  --port 30000
```

**FP8 (pour H100/A100) :**

```bash
python3 -m sglang.launch_server \
  --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
  --quantization fp8 \
  --host 0.0.0.0 \
  --port 30000
```

***

## Conseils de performance

### 1. RadixAttention — L'avantage clé

RadixAttention de SGLang réutilise automatiquement le cache KV pour les préfixes de prompt partagés. C'est particulièrement puissant pour :

* Chatbots avec de longs prompts système
* Applications RAG avec contexte répété
* Appels API par lot partageant le même préfixe

Aucune configuration supplémentaire n'est nécessaire — c'est toujours activé.

### 2. Augmenter la taille du cache KV

```bash
--mem-fraction-static 0.90  # Utiliser 90 % de la VRAM pour le cache KV
```

Faites attention à ne pas aller trop haut — laissez de la place pour les poids du modèle.

### 3. Préremplissage par blocs pour les contextes longs

```bash
--chunked-prefill-size 4096  # Traiter les prompts longs par blocs
```

### 4. Activer le backend FlashInfer

SGLang utilise automatiquement FlashInfer lorsqu'il est disponible (GPU Ampere+) :

```bash
--attention-backend flashinfer
```

### 5. Parallélisme tensoriel multi-GPU

Pour les modèles qui ne tiennent pas sur un seul GPU :

```bash
--tp 4  # Utiliser 4 GPU
```

Chaque GPU doit avoir suffisamment de VRAM pour une partition du modèle.

### 6. Ajuster pour le débit vs la latence

**Faible latence (utilisateur unique) :**

```bash
--max-running-requests 4
```

**Débit élevé (nombreux utilisateurs) :**

```bash
--max-running-requests 64 \
--schedule-policy lpm  # Planification Longest Prefix Match
```

***

## Dépannage

### Problème : "torch.cuda.OutOfMemoryError"

```
torch.cuda.OutOfMemoryError : mémoire CUDA insuffisante
```

**Solution :** Réduisez la fraction mémoire ou utilisez la quantification :

```bash
--mem-fraction-static 0.80
# ou
--quantization awq
```

### Problème : le serveur ne démarre pas (bloqué au chargement)

```bash
# Vérifier la disponibilité de CUDA
docker exec -it sglang nvidia-smi

# Vérifier la progression du téléchargement du modèle
docker logs -f sglang 2>&1 | tail -50
```

### Problème : "trust\_remote\_code required"

Ajoutez `--trust-remote-code` à la commande de lancement pour les modèles avec des architectures personnalisées (DeepSeek, Falcon, etc.).

### Problème : génération lente sur les modèles MoE

Les modèles MoE (Mixtral, DeepSeek) sont limités par la bande passante mémoire. Assurez-vous d'utiliser :

```bash
--dtype bfloat16  # Mieux que float16 pour MoE
--tp 2            # Répartir sur plusieurs GPU si disponible
```

### Problème : erreurs de longueur de contexte

```bash
# Remplacer la longueur du contexte
--context-length 32768
```

### Problème : le port 30000 n'est pas accessible

Vérifiez que le port est exposé dans la configuration de votre commande CLORE.AI. Consultez l'URL http\_pub dans le tableau de bord de votre commande, pas localhost.

***

## Liens

* [GitHub](https://github.com/sgl-project/sglang)
* [Documentation](https://sgl-project.github.io/start/install.html)
* [Docker Hub](https://hub.docker.com/r/lmsysorg/sglang)
* [Modèles pris en charge](https://github.com/sgl-project/sglang?tab=readme-ov-file#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/h           |

> 💡 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/sglang.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.