vLLM

Inférence LLM à haut débit avec vLLM sur les GPU Clore.ai

Serveur d’inférence LLM à haut débit pour les charges de production sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Version actuelle : v0.7.x — Ce guide couvre vLLM v0.7.3+. Les nouvelles fonctionnalités incluent la prise en charge de DeepSeek-R1, des sorties structurées avec choix automatique d’outil, le service multi-LoRA et une meilleure efficacité mémoire.

Exigences du serveur

Paramètre	Minimum	Recommandé
RAM	16 Go	32 Go+
VRAM	16 Go (7B)	24 Go+
Réseau	500 Mbit/s	1 Gbit/s+
Temps de démarrage	5 à 15 minutes	-

Besoin d’un GPU adapté ? Un RTX 4090 (24 Go) gère confortablement les modèles 7B–13B ; pour les modèles 70B+, un H100 (80 Go) est le choix le plus sûr.

Important : vLLM nécessite une RAM et une VRAM importantes. Les serveurs disposant de moins de 16 Go de RAM ne pourront pas exécuter même les modèles 7B.

Temps de démarrage : Le premier lancement télécharge le modèle depuis HuggingFace (5 à 15 minutes selon la taille du modèle et la vitesse du réseau). Un HTTP 502 pendant ce temps est normal.

Pourquoi vLLM ?

• Débit le plus rapide - PagedAttention pour un débit 24x supérieur

• Prêt pour la production - API compatible OpenAI prête à l’emploi

• Batching continu - Service multi-utilisateur efficace

• Streaming - Génération de jetons en temps réel

• Multi-GPU - Parallélisme tensoriel pour les grands modèles

• Multi-LoRA - Servez simultanément plusieurs adaptateurs fine-tunés (v0.7+)

• Sorties structurées - Application de schéma JSON et appel d’outil (v0.7+)

Déploiement rapide sur CLORE.AI

Image Docker :

vllm/vllm-openai:v0.7.3

Ports :

22/tcp
8000/http

Commande :

vllm serve mistralai/Mistral-7B-Instruct-v0.2 --host 0.0.0.0 --port 8000

Vérifier que cela fonctionne

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

# Vérifier l’état de santé (peut prendre 5 à 15 min au premier lancement)
curl https://your-http-pub.clorecloud.net/health

# Lister les modèles (fonctionne seulement après le chargement du modèle)
curl https://your-http-pub.clorecloud.net/v1/models

Si vous obtenez un HTTP 502 pendant plus de 15 minutes, vérifiez :

1. Le serveur dispose de 16 Go+ de RAM

2. Le serveur dispose de suffisamment de VRAM pour le modèle

3. Le jeton HuggingFace est défini pour les modèles à accès restreint

Accéder à votre service

Lorsqu’il est déployé sur CLORE.AI, accédez à vLLM via l’ http_pub URL :

# Complétion de chat
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Tous localhost:8000 les exemples ci-dessous fonctionnent lorsque la connexion se fait via SSH. Pour un accès externe, remplacez par votre https://your-http-pub.clorecloud.net/ URL.

Installation

Utilisation de Docker (recommandé)

docker run -d --gpus all \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:v0.7.3 \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0

Utilisation de pip

pip install vllm==0.7.3

# Lancer le serveur
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2

Modèles pris en charge

Modèle	Paramètres	VRAM requise	RAM requise
Mistral 7B	7B	14 Go	16 Go+
Llama 3.1 8B	8B	16 Go	16 Go+
Llama 3.1 70B	70B	140 Go (ou 2x80 Go)	64 Go+
Mixtral 8x7B	47B	90 Go	32 Go+
Qwen2.5 7B	7B	14 Go	16 Go+
Qwen2.5 72B	72B	145 Go	64 Go+
DeepSeek-V3	236B MoE	Multi-GPU	128 Go+
DeepSeek-R1-Distill-Qwen-7B	7B	14 Go	16 Go+
DeepSeek-R1-Distill-Qwen-32B	32B	64 Go	32 Go+
DeepSeek-R1-Distill-Llama-70B	70B	140 Go	64 Go+
Phi-4	14B	28 Go	32 Go+
Gemma 2 9B	9B	18 Go	16 Go+
CodeLlama 34B	34B	68 Go	32 Go+

Options du serveur

Serveur de base

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000

Serveur de production

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 256 \
    --enable-prefix-caching

Avec quantification (VRAM réduite)

# Modèle quantifié AWQ (utilise moins de VRAM)
vllm serve TheBloke/Mistral-7B-Instruct-v0.2-AWQ \
    --host 0.0.0.0 \
    --quantization awq

Sorties structurées et appel d’outil (v0.7+)

Activez le choix automatique d’outil et les sorties JSON structurées :

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral

Utilisation en Python :

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo actuelle pour une ville",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nom de la ville"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Quelle est la météo à Paris ?"}],
    tools=tools,
    tool_choice="auto"
)

# Analyser l’appel d’outil
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print(f"Outil : {tool_call.function.name}, Arguments : {args}")

Sortie JSON structurée via le format de réponse :

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Extraire : John Smith, 30 ans, ingénieur logiciel"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)
print(response.choices[0].message.content)

Service Multi-LoRA (v0.7+)

Servez un modèle de base avec plusieurs adaptateurs LoRA simultanément :

vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --enable-lora \
    --lora-modules \
        sql-adapter=path/to/sql-lora \
        code-adapter=path/to/code-lora \
        chat-adapter=path/to/chat-lora \
    --max-lora-rank 64

Interrogez un adaptateur LoRA spécifique par nom de modèle :

# Utiliser l’adaptateur SQL
response = client.chat.completions.create(
    model="sql-adapter",
    messages=[{"role": "user", "content": "Écris une requête SQL pour trouver les 10 meilleurs clients"}]
)

# Utiliser l’adaptateur code
response = client.chat.completions.create(
    model="code-adapter",
    messages=[{"role": "user", "content": "Écris une fonction Python pour trier une liste"}]
)

Prise en charge de DeepSeek-R1 (v0.7+)

vLLM v0.7+ prend en charge nativement les modèles distillés DeepSeek-R1. Ces modèles de raisonnement produisent <think> des balises montrant leur processus de raisonnement.

DeepSeek-R1-Distill-Qwen-7B (GPU unique)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384

DeepSeek-R1-Distill-Qwen-32B (double GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90

DeepSeek-R1-Distill-Llama-70B (quadruple GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768

Interrogation de DeepSeek-R1

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[
        {
            "role": "user",
            "content": "Résoudre : si un train parcourt 120 km en 1,5 heure, quelle est sa vitesse en m/s ?"
        }
    ],
    max_tokens=2048,
    temperature=0.6
)

content = response.choices[0].message.content
# La réponse inclut un bloc de raisonnement <think>...</think> suivi de la réponse
print(content)

Analyse des balises think :

import re

def parse_deepseek_r1_response(content: str) -> dict:
    """Extraire le raisonnement et la réponse de la réponse DeepSeek-R1."""
    think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
    return {"thinking": thinking, "answer": answer}

result = parse_deepseek_r1_response(content)
print("Raisonnement :", result["thinking"][:200], "...")
print("Réponse :", result["answer"])

Utilisation de l’API

Complétions de chat (compatible OpenAI)

from openai import OpenAI

# Pour un accès externe, utilisez votre URL http_pub :
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="not-needed"
)

# Ou via un tunnel SSH :
# client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "user", "content": "Explique l’informatique quantique"}
    ],
    max_tokens=500,
    temperature=0.7
)

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

Streaming

stream = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Écris un poème"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

cURL

curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'

Complétions de texte

curl https://your-http-pub.clorecloud.net/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "La capitale de la France est",
    "max_tokens": 50
  }'

Référence complète de l’API

vLLM fournit des points de terminaison compatibles OpenAI ainsi que des points de terminaison utilitaires supplémentaires.

Points de terminaison standard

Point de terminaison	Méthode	Description
/v1/models	GET	Lister les modèles disponibles
/v1/chat/completions	POST	Complétion de chat
/v1/completions	POST	Complétion de texte
/health	GET	Vérification de l’état de santé (peut renvoyer vide)

Points de terminaison supplémentaires

Point de terminaison	Méthode	Description
/tokenize	POST	Tokeniser le texte
/detokenize	POST	Convertir les jetons en texte
/version	GET	Obtenir la version de vLLM
/docs	GET	Documentation Swagger UI
/metrics	GET	Métriques Prometheus

Tokeniser le texte

Utile pour compter les jetons avant d’envoyer des requêtes :

curl https://your-http-pub.clorecloud.net/tokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Bonjour le monde"
  }'

Réponse :

{"count": 2, "max_model_len": 32768, "tokens": [9707, 1879]}

Détokeniser

Convertir les identifiants de jetons en texte :

curl https://your-http-pub.clorecloud.net/detokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "tokens": [9707, 1879]
  }'

Réponse :

{"prompt": "Bonjour le monde"}

Obtenir la version

curl https://your-http-pub.clorecloud.net/version

Réponse :

{"version": "0.7.3"}

Documentation Swagger

Ouvrez dans le navigateur pour une documentation API interactive :

https://your-http-pub.clorecloud.net/docs

Métriques Prometheus

Pour la surveillance :

curl https://your-http-pub.clorecloud.net/metrics

Modèles de raisonnement : DeepSeek-R1 et des modèles similaires incluent <think> des balises dans les réponses montrant le processus de raisonnement du modèle avant la réponse finale.

Benchmarks

Débit (jetons/s par utilisateur)

Modèle	RTX 3090	RTX 4090	A100 40 Go	A100 80 Go
Mistral 7B	100	170	210	230
Llama 3.1 8B	95	150	200	220
Llama 3.1 8B (AWQ)	130	190	260	280
Mixtral 8x7B	-	45	70	85
Llama 3.1 70B	-	-	25 (2x)	45 (2x)
DeepSeek-R1 7B	90	145	190	210
DeepSeek-R1 32B	-	-	40	70 (2x)

Benchmarks mis à jour en janvier 2026.

Longueur de contexte vs VRAM

Modèle	ctx 4K	ctx 8K	ctx 16K	ctx 32K
8B FP16	18 Go	22 Go	30 Go	46 Go
8B AWQ	8 Go	10 Go	14 Go	22 Go
70B FP16	145 Go	160 Go	190 Go	250 Go
70B AWQ	42 Go	50 Go	66 Go	98 Go

Authentification Hugging Face

Pour les modèles à accès restreint (Llama, etc.) :

# Définir le jeton dans la commande
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --env HUGGING_FACE_HUB_TOKEN=hf_xxxxx

Ou définir comme variable d’environnement :

export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

Exigences GPU

Modèle	VRAM min.	RAM min.	Recommandé
7-8B	16 Go	16 Go	24 Go VRAM, 32 Go RAM
13B	26 Go	32 Go	40 Go VRAM
34B	70 Go	32 Go	80 Go VRAM
70B	140 Go	64 Go	2x80 Go

Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

GPU	VRAM	Prix/jour	Idéal pour
RTX 3090	24 Go	0,30 $–1,00 $	Modèles 7-8B
RTX 4090	24 Go	0,50 $–2,00 $	7-13B, rapide
A100	40 Go	1,50 $–3,00 $	Modèles 13-34B
A100	80 Go	2,00 $–4,00 $	Modèles 34-70B

Prix en USD/jour. Les tarifs varient selon le fournisseur — consultez CLORE.AI Marketplace pour connaître les tarifs actuels.

Dépannage

HTTP 502 pendant longtemps

1. Vérifiez la RAM : Le serveur doit disposer de 16 Go+ de RAM

2. Vérifiez la VRAM : Doit pouvoir contenir le modèle

3. Téléchargement du modèle : Le premier lancement télécharge depuis HuggingFace (5 à 15 min)

4. Jeton HF : Les modèles à accès restreint nécessitent une authentification

Mémoire insuffisante

# Réduire l’utilisation mémoire
--gpu-memory-utilization 0.8
--max-model-len 4096
--max-num-seqs 64

# Ou utilisez la quantification
--quantization awq

Échec du téléchargement du modèle

# Vérifier le jeton HF
echo $HUGGING_FACE_HUB_TOKEN

# Pré-télécharger le modèle
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.2

vLLM contre les autres

Fonctionnalité	vLLM	llama.cpp	Ollama
Débit	Meilleur	Bon	Bon
Utilisation de la VRAM	Élevée	Faible	Moyenne
Facilité d’utilisation	Moyenne	Moyenne	Facile
Temps de démarrage	5-15 min	1-2 min	30 s
Multi-GPU	Natif	Limité	Limité
Appel d’outils	Oui (v0.7+)	Limité	Limité
Multi-LoRA	Oui (v0.7+)	Non	Non

Utilisez vLLM lorsque :

• Le débit élevé est prioritaire

• Servir plusieurs utilisateurs

• Avoir suffisamment de VRAM et de RAM

• Déploiement en production

• Besoin d’appel d’outils / de sorties structurées

Utilisez Ollama lorsque :

• Configuration rapide nécessaire

• Utilisateur unique

• Moins de ressources disponibles

Étapes suivantes

• Ollama - Alternative plus simple avec un démarrage plus rapide

• DeepSeek-R1 - Guide du modèle de raisonnement

• DeepSeek-V3 - Meilleur modèle polyvalent

• Qwen2.5 - Modèles multilingues

• Llama.cpp - Option à plus faible consommation de VRAM