Skip to content
Learni
View all tutorials
Intelligence Artificielle

Comment utiliser vLLM pour l'inférence LLM en 2026

12 minBEGINNER
PythonvLLMLLMInferenceGPU

Introduction

vLLM est un moteur d'inférence open-source pour les grands modèles de langage (LLM), conçu pour une vitesse et une efficacité exceptionnelles. Lancé en 2023, il utilise la technique PagedAttention pour optimiser la mémoire GPU, permettant jusqu'à 4x plus de throughput que des alternatives comme Hugging Face Transformers. En 2026, avec l'essor des agents IA et des applications en temps réel, vLLM est indispensable pour les développeurs qui déploient des modèles localement sans compromettre les performances.

Pourquoi l'utiliser ? Imaginez servir un modèle comme Llama 3 à 100 requêtes/seconde sur un GPU unique, au lieu de 20-30 avec des outils standards. Ce tutoriel beginner vous guide de l'installation au déploiement, avec du code complet et fonctionnel. À la fin, vous saurez lancer un serveur compatible OpenAI et interroger vos LLM en production. Idéal pour les prototypes RAG, chatbots ou APIs IA scalables. (128 mots)

Prérequis

  • Python 3.9+ installé
  • GPU NVIDIA avec CUDA 11.8+ (ou CPU pour tests, mais lent)
  • 16 Go RAM minimum, 8 Go VRAM pour modèles petits
  • Compte Hugging Face (gratuit) pour télécharger des modèles
  • pip et git installés
  • Familiarité basique avec la ligne de commande et Python

Installation de vLLM

terminal
pip install vllm==0.6.1.post1

# Vérification
python -c "from vllm import LLM; print('vLLM installé avec succès!')"

# Optionnel : pour GPU Ampere+ (A100, RTX 40xx)
pip install vllm[flashinfer]

# Installer torch avec CUDA si pas déjà fait
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

Cette commande installe vLLM et ses dépendances. La version pinned évite les breaks. Le flag flashinfer booste les perfs sur GPU récents. Testez immédiatement pour valider CUDA ; sinon, fallback CPU lent.

Téléchargement d'un modèle de test

Choisissez un petit modèle pour débuter : TinyLlama-1.1B-Chat-v1.0 (1.1B params, rapide sur GPU 8Go). vLLM supporte 1000+ modèles Hugging Face. Évitez les gated comme Llama sans token ; utilisez huggingface-cli login pour auth.

Lancer le serveur OpenAI-compatible

terminal-serveur
vllm serve TinyLlama/TinyLlama-1.1B-Chat-v1.0 \
  --host 0.0.0.0 \
  --port 8000 \
  --tensor-parallel-size 1 \
  --dtype auto \
  --trust-remote-code

# Le serveur est prêt ! Accédez à http://localhost:8000/docs pour Swagger UI

Ce commande lance un serveur REST/HTTP compatible OpenAI sur port 8000. --host 0.0.0.0 permet l'accès distant. --tensor-parallel-size 1 pour un seul GPU. Le serveur auto-charged le modèle et expose /v1/chat/completions.

Tester le serveur avec curl

vLLM émule l'API OpenAI : endpoints /v1/models, /v1/completions, /v1/chat/completions. Utilisez curl ou Swagger pour valider. Analogie : comme ChatGPT API, mais local et gratuit.

Requête curl sur le serveur

terminal-curl
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
    "messages": [
      {"role": "system", "content": "Tu es un assistant utile."},
      {"role": "user", "content": "Explique vLLM en 3 mots."}
    ],
    "temperature": 0.7,
    "max_tokens": 128
  }'

Ce curl envoie un prompt chat et reçoit une réponse JSON. max_tokens limite la génération. Copiez-collez directement ; ajustez temperature pour créativité (0=déterministe, 1=aléatoire).

Client Python avec openai library

client.py
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="token-fake"  # vLLM ignore la clé
)

response = client.chat.completions.create(
    model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
    messages=[
        {"role": "system", "content": "Tu es un expert Python."},
        {"role": "user", "content": "Écris une fonction fizzbuzz."}
    ],
    temperature=0.1,
    max_tokens=200
)

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

Ce script utilise la lib OpenAI pour query vLLM sans changer de code. base_url pointe le serveur local. Idéal pour migrer d'OpenAI vers local. Exécutez pip install openai avant.

Utilisation standalone sans serveur

Pour scripts batch ou notebooks, utilisez la classe LLM de vLLM directement. Pas de serveur, inférence synchrone/asynchrone. Parfait pour data processing ou fine-tuning eval.

Inférence standalone avec LLM class

standalone.py
from vllm import LLM, SamplingParams

llm = LLM(
    model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
    tensor_parallel_size=1,
    dtype="auto"
)

prompts = [
    "<|system|>\nTu es un assistant.\n<|user|>\nBonjour ! Comment ça va ?<|end|>\n<|assistant|>\n",
    "<|system|>\nTu es un assistant.\n<|user|>\n2+2=?<|end|>\n<|assistant|>\n"
]

sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=64)

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}, Generated: {generated_text!r}")

Charge le modèle en mémoire et génère pour plusieurs prompts en batch. SamplingParams contrôle la génération (top_p évite répétitions). Format TinyLlama avec tokens spéciaux. Efficace pour 1000+ inférences.

Configuration avancée avec quantization

terminal-quantized
vllm serve TinyLlama/TinyLlama-1.1B-Chat-v1.0 \
  --quantization awq \
  --host 0.0.0.0 \
  --port 8001 \
  --max-model-len 4096 \
  --gpu-memory-utilization 0.9 \
  --trust-remote-code

# Pour plus de modèles simultanés
vllm serve --model TinyLlama/TinyLlama-1.1B-Chat-v1.0 --served-model-name tinyllama-chat

AWQ quantization réduit VRAM x2 sans perte majeure. --max-model-len limite contexte. --gpu-memory-utilization 0.9 maximise usage GPU. --served-model-name renomme pour API.

Déploiement Docker

Dockerfile
FROM vllm/vllm-openai:latest

WORKDIR /app

COPY entrypoint.sh /app/entrypoint.sh
RUN chmod +x /app/entrypoint.sh

ENTRYPOINT ["/app/entrypoint.sh"]

# Build: docker build -t vllm-server .
# Run: docker run --gpus all -p 8000:8000 vllm-server \
#   --env HF_TOKEN=your_token \
#   vllm serve TinyLlama/TinyLlama-1.1B-Chat-v1.0 --host 0.0.0.0

Image officielle vLLM pour prod. Ajoutez entrypoint.sh pour args dynamiques. --gpus all expose GPU Docker. Scalable sur Kubernetes.

Bonnes pratiques

  • Batch requests : Envoyez 10-100 prompts en parallèle pour max throughput.
  • Quantize toujours : AWQ/GPTQ pour >7B models sur <24Go VRAM.
  • Monitor GPU : nvidia-smi -l 1 pendant serve ; ajustez --gpu-memory-utilization.
  • Prompt engineering : Utilisez formats chat natifs (ex: [INST] ).
  • Cache KV : Activez --enable-prefix-caching pour RAG réutilisable.

Erreurs courantes à éviter

  • OOM GPU : Réduisez --max-model-len ou quantize ; ne chargez pas 70B sans A100.
  • Modèle gated : huggingface-cli login avant serve, ou OOM faux.
  • Port occupé : Kill process lsof -ti:8000 | xargs kill -9.
  • CUDA mismatch : Vérifiez torch.cuda.is_available() ; réinstallez torch cu121.

Pour aller plus loin