> 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

SGLang (Structured Generation Language) est un cadre de service LLM haute performance développé par l'équipe LMSYS, connue pour leurs travaux sur Vicuna et Chatbot Arena. Il intègre RadixAttention pour le partage du cache KV, prend en charge efficacement MoE (Mixture of Experts) et propose une API compatible 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 [CLORE.AI Marketplace](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 ses 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`       | GPUs à utiliser                             |

## Configuration étape par étape

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

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

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

### 2. SSH sur votre serveur

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

### 3. Récupérez l'image Docker SGLang

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

### 4. Lancez le serveur SGLang

**Lancement basique (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 le 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 la santé du serveur

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

# Vérification de santé (attendre ~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ès externe via le proxy CLORE.AI

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

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

Utilisez cette URL comme URL de base dans tout client compatible OpenAI.

***

## Exemples d'utilisation

### Exemple 1 : Chat Completions 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

# Pointez vers votre serveur SGLang CLORE.AI
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang n'exige 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": "The future of AI is",
        "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": "Extract information: John Smith, 35 years old, lives in 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

### Principaux paramètres de lancement

| Paramètre               | Par défaut          | Description                                                |
| ----------------------- | ------------------- | ---------------------------------------------------------- |
| `--model-path`          | requis              | ID du 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 (nombre de GPUs)           |
| `--dp`                  | `1`                 | Degré de parallélisme de 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 maximal de tokens dans une étape de pré-remplissage |
| `--context-length`      | max du modèle       | Remplacer la longueur de contexte maximale                 |
| `--trust-remote-code`   | false               | Autoriser le code personnalisé du modèle                   |
| `--quantization`        | aucune              | `awq`, `gptq`, `fp8`                                       |
| `--load-format`         | `auto`              | `auto`, `pt`, `safetensors`                                |
| `--tokenizer-path`      | identique au modèle | Chemin du tokenizer personnalisé                           |

### 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é

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

* Chatbots avec de longues instructions système
* Applications RAG avec contexte répété
* Appels d'API en lot partageant le même préfixe

Aucune configuration supplémentaire 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 trop augmenter — laissez de la place pour les poids du modèle.

### 3. Pré-remplissage en morceaux pour les contextes longs

```bash
--chunked-prefill-size 4096  # Traiter les invites longues par morceaux
```

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

Chaque GPU doit avoir suffisamment de VRAM pour une portion (shard) du modèle.

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

**Faible latence (utilisateur unique) :**

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

**Haut débit (plusieurs utilisateurs) :**

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

***

## Dépannage

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

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

**Solution :** Réduire la fraction de mémoire ou utiliser 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"

Ajouter `--trust-remote-code` à la commande de lancement pour les modèles avec 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 GPUs si disponible
```

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

```bash
# Remplacer la longueur de 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)
* [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/heure       |
| Production (7B–13B)   | RTX 4090 (24GB)  | \~0,70 $/GPU/heure       |
| Grands modèles (70B+) | A100 80GB / H100 | \~1,20 $/GPU/heure       |

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