vLLM Quickstart: Hoogpresterende LLM-berekening - in 2026

vLLM is een inference- en serving-engine met hoge doorvoer en geheugenefficiëntie voor Large Language Models (LLM’s), ontwikkeld door het Sky Computing Lab van UC Berkeley.

Met zijn revolutionaire PagedAttention-algoritme behaalt vLLM een 14-24 keer hogere doorvoer dan traditionele serving-methoden, waardoor het de eerste keuze is voor productiedeployments van LLM’s. Om te zien hoe vLLM zich verhoudt tot Ollama, Docker Model Runner, LocalAI en cloudproviders – inclusief kosten- en infrastructuurafwegingen – zie LLM Hosting: Lokaal, Zelf-Gehost & Cloud Infrastructuur Vergelijk.

Wat is vLLM?

vLLM (virtual LLM) is een open-source bibliotheek voor snelle LLM-inference en serving die zich snel heeft ontwikkeld tot de industriestandaard voor productiedeployments. In 2023 uitgebracht, introduceerde het PagedAttention, een baanbrekende techniek voor geheugbeheer die de serving-efficiëntie drastisch verbetert.

Belangrijke Functies

Hoge Doorvoer Prestaties: vLLM levert 14-24 keer hogere doorvoer vergeleken met HuggingFace Transformers met dezelfde hardware. Deze enorme prestatiewinst komt voort uit continu batching, geoptimaliseerde CUDA-kernels en het PagedAttention-algoritme dat geheugenfragmentatie elimineert.

OpenAI API Compatibiliteit: vLLM bevat een ingebouwde API-server die volledig compatibel is met OpenAI’s formaat. Dit maakt een naadloze migratie van OpenAI naar zelf-gehoste infrastructuur mogelijk zonder wijzigingen in de applicatiecode. Wijs uw API-client eenvoudig naar vLLM’s endpoint en het werkt transparant.

PagedAttention Algoritme: De kerninnovatie achter vLLM’s prestaties is PagedAttention, dat het concept van virtuele geheugenpagina-indeling toepast op attention-mechanismen. In plaats van contigu geheugenblokken toe te wijzen voor KV-caches (wat leidt tot fragmentatie), deelt PagedAttention het geheugen op in blokken met vaste grootte die on-demand kunnen worden toegewezen. Dit vermindert geheugenverspilling tot wel 4x en maakt veel grotere batchgroottes mogelijk.

Continue Batching: In tegenstelling tot statisch batching waarbij je wacht tot alle sequenties voltooid zijn, gebruikt vLLM continue (rolende) batching. Zodra één sequentie voltooid is, kan er direct een nieuwe aan de batch worden toegevoegd. Dit maximaliseert GPU-utilisatie en minimaliseert latentie voor inkomende requests.

Multi-GPU Ondersteuning: vLLM ondersteunt tensor parallelisme en pipeline parallelisme voor het verdelen van grote modellen over meerdere GPU’s. Het kan efficiënt modellen serveren die niet in het geheugen van één enkele GPU passen, en ondersteunt configuraties van 2 tot 8+ GPU’s.

Brede Modelondersteuning: Compatibel met populaire modelarchitecturen waaronder LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma en vele anderen. Ondersteunt zowel instructie-getuned als base-modellen van de HuggingFace Hub.

Wanneer vLLM Gebruiken

vLLM blinkt uit in specifieke scenario’s waar zijn sterktes tot hun recht komen:

Productie API Diensten: Wanneer u een LLM aan vele gelijktijdige gebruikers wilt serveren via API, is vLLM’s hoge doorvoer en efficiënte batching de beste keuze. Bedrijven die chatbots, code-assistenten of contentgeneratiediensten runnen, profiteren van het vermogen om honderden requests per seconde te verwerken.

Hoge Concurrentie Lasten: Als uw applicatie vele gelijktijdige gebruikers heeft die requests doen, maken vLLM’s continue batching en PagedAttention het mogelijk meer gebruikers te serveren met dezelfde hardware vergeleken met alternatieven.

Kostenoptimalisatie: Wanneer GPU-kosten een zorg zijn, betekent vLLM’s superieure doorvoer dat u hetzelfde verkeer kunt serveren met minder GPU’s, wat de infrastructuurkosten direct verlaagt. De 4x geheugenefficiëntie van PagedAttention maakt ook het gebruik van kleinere, goedkopere GPU-instanties mogelijk.

Kubernetes Deployments: vLLM’s stateless ontwerp en container-vriendelijke architectuur maken het ideaal voor Kubernetes-clusters. De consistente prestaties onder belasting en eenvoudige resourcebeheer integreren goed met cloud-native infrastructuur.

Wanneer NIET vLLM Gebruiken: Voor lokale ontwikkeling, experimenten of single-user scenario’s bieden tools zoals Ollama of llama.cpp een betere gebruikerservaring met eenvoudigere setup. vLLM’s complexiteit is gerechtvaardigd wanneer u zijn prestatievoordelen nodig heeft voor productie-lasten.

vLLM Installeren

Voorvereisten

Voordat u vLLM installeert, zorg ervoor dat uw systeem aan deze vereisten voldoet:

• GPU: NVIDIA GPU met compute capability 7.0+ (V100, T4, A10, A100, H100, RTX 20/30/40 series)
• CUDA: Versie 11.8 of hoger
• Python: 3.8 tot 3.11
• VRAM: Minimaal 16GB voor 7B-modellen, 24GB+ voor 13B, 40GB+ voor grotere modellen
• Driver: NVIDIA driver 450.80.02 of nieuwer

Installatie via pip

De eenvoudigste installatiemethode is het gebruik van pip. Dit werkt op systemen met CUDA 11.8 of nieuwer:

# Maak een virtuele omgeving (aanbevolen)
python3 -m venv vllm-env
source vllm-env/bin/activate

# Installeer vLLM
pip install vllm

# Verifieer installatie
python -c "import vllm; print(vllm.__version__)"

Voor systemen met verschillende CUDA-versies, installeer de juiste wheel:

# Voor CUDA 12.1
pip install vllm==0.4.2+cu121 -f https://github.com/vllm-project/vllm/releases

# Voor CUDA 11.8
pip install vllm==0.4.2+cu118 -f https://github.com/vllm-project/vllm/releases

Installatie met Docker

Docker biedt de meest betrouwbare deploymethode, vooral voor productie:

# Pull de officiële vLLM image
docker pull vllm/vllm-openai:latest

# Draai vLLM met GPU-ondersteuning
docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-7B-Instruct-v0.2

De --ipc=host flag is belangrijk voor multi-GPU setups omdat het juiste inter-process communicatie mogelijk maakt.

Bouwen vanuit broncode

Voor de nieuwste functies of aangepaste modificaties, bouw vanuit broncode:

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

vLLM Snelstartgids

Uw Eerste Model Draaien

Start vLLM met een model via de command-line interface:

# Download en serveer Mistral-7B met OpenAI-compatibele API
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000

vLLM zal automatisch het model downloaden van de HuggingFace Hub (indien niet gecached) en de server starten. U ziet output die aangeeft dat de server klaar is:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000

API Requests Maken

Zodra de server draait, kunt u requests maken met de OpenAI Python client of curl:

Met curl:

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.2",
        "prompt": "Leg uit wat vLLM is in één zin:",
        "max_tokens": 100,
        "temperature": 0.7
    }'

Met OpenAI Python Client:

from openai import OpenAI

# Wijs naar uw vLLM server
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM vereist geen authenticatie standaard
)

response = client.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    prompt="Leg uit wat vLLM is in één zin:",
    max_tokens=100,
    temperature=0.7
)

print(response.choices[0].text)

Chat Completions API:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "system", "content": "Je bent een behulpzame assistent."},
        {"role": "user", "content": "Wat is PagedAttention?"}
    ],
    max_tokens=200
)

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

Geavanceerde Configuratie

vLLM biedt talloze parameters om prestaties te optimaliseren:

python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000 \
    --gpu-memory-utilization 0.95 \  # Gebruik 95% van GPU geheugen
    --max-model-len 8192 \            # Maximale sequentiële lengte
    --tensor-parallel-size 2 \        # Gebruik 2 GPU's met tensor parallelisme
    --dtype float16 \                 # Gebruik FP16 precisie
    --max-num-seqs 256                # Maximale batchgrootte

Belangrijke Parameters Uitgelegd:

• --gpu-memory-utilization: Hoeveel GPU geheugen te gebruiken (0.90 = 90%). Hogere waarden laten grotere batches toe, maar laten minder marge voor geheugenpieken over.
• --max-model-len: Maximale contextlengte. Het reduceren hiervan bespaart geheugen voor grotere batches.
• --tensor-parallel-size: Aantal GPU’s om het model over te splitsen.
• --dtype: Gegevenstype voor gewichten (float16, bfloat16, of float32). FP16 is meestal optimaal.
• --max-num-seqs: Maximaal aantal sequenties om in een batch te verwerken.

vLLM vs Ollama Vergelijking

Zowel vLLM als Ollama zijn populaire keuzes voor lokale LLM-hosting, maar ze richten zich op verschillende use cases. Begrip van wanneer elk te gebruiken, kan de succes van uw project aanzienlijk beïnvloeden.

Prestaties en Doorvoer

vLLM is ontworpen voor maximale doorvoer in multi-user scenario’s. Zijn PagedAttention en continue batching maken het serveren van honderden gelijktijdige requests efficiënt mogelijk. Benchmarken tonen aan dat vLLM 14-24 keer hogere doorvoer bereikt dan standaard implementaties en 2-4 keer hoger dan Ollama onder hoge concurrentie.

Ollama optimaliseert voor single-user interactief gebruik met focus op lage latentie voor individuele requests. Hoewel het vLLM’s multi-user doorvoer niet evenaart, biedt het uitstekende prestaties voor ontwikkeling en persoonlijk gebruik met snellere cold-start tijden en lager idle resource verbruik.

Gebruiksgemak

Ollama wint duidelijk op eenvoud. Installatie is één commando (curl | sh), en het draaien van modellen is zo eenvoudig als ollama run llama2. Het bevat een modelbibliotheek met gekwantificeerde versies geoptimaliseerd voor verschillende hardwareprofielen. De gebruikerservaring lijkt op Docker – pull, run, en ga.

vLLM vereist meer setup: Python omgeving beheer, CUDA installatie, begrip van serving parameters, en handmatige model specificatie. De leercurve is steiler, maar u krijgt fijngedetailleerde controle over prestatiesoptimalisatie. Deze complexiteit is gerechtvaardigd voor productiedeployments waar u maximale prestaties van uw hardware moet persen.

API en Integratie

vLLM biedt op maat gemaakte OpenAI-compatibele REST APIs out of the box, waardoor het een drop-in vervanging is voor OpenAI’s API in bestaande applicaties. Dit is cruciaal voor het migreren van productiediensten van cloudproviders naar zelf-gehoste infrastructuur zonder codeveranderingen.

Ollama biedt een eenvoudigere REST API en een dedicated Python/JavaScript bibliotheek. Hoewel functioneel, is het niet OpenAI-compatibel, wat vereist dat codeveranderingen worden gemaakt bij integratie met applicaties die OpenAI’s formaat verwachten. Communityprojecten zoals Ollama-OpenAI adapters sluiten echter deze kloof.

Geheugenbeheer

vLLM’s PagedAttention algoritme biedt superieure geheugenefficiëntie voor gelijktijdige requests. Het kan 2-4 keer meer gelijktijdige gebruikers serveren met hetzelfde VRAM vergeleken met naïeve implementaties. Dit vertaalt zich direct naar kostenbesparing in productiedeployments.

Ollama gebruikt eenvoudiger geheugenbeheer geschikt voor single-user scenario’s. Het beheert automatisch het laden/ontladen van modellen op basis van activiteit, wat handig is voor ontwikkeling, maar niet optimaal voor hoge-concurrentie productiegebruik.

Multi-GPU Ondersteuning

vLLM blinkt uit met native tensor parallelisme en pipeline parallelisme, en verdeelt efficiënt modellen over 2-8+ GPU’s. Dit is essentieel voor het serveren van grote modellen zoals 70B parameter LLM’s die niet in één enkele GPU passen.

Ollama heeft momenteel beperkte multi-GPU ondersteuning en werkt het beste met één enkele GPU. Dit maakt het minder geschikt voor zeer grote modellen die gedistribueerde inference vereisen.

Use Case Aanbevelingen

Kies vLLM wanneer:

• Productie APIs serveert met vele gelijktijdige gebruikers
• Kosten per request optimaliseert in clouddeployments
• In Kubernetes of container orchestration platforms draait
• OpenAI API compatibiliteit nodig heeft voor bestaande applicaties
• Grote modellen serveert die multi-GPU ondersteuning vereisen
• Prestaties en doorvoer kritieke vereisten zijn

Kies Ollama wanneer:

• Lokale ontwikkeling en experimentatie
• Single-user interactief gebruik (persoonlijke assistenten, chatbots)
• Snel prototyping en model evaluatie
• Over LLM’s leert zonder infrastructuurcomplexiteit
• Draait op persoonlijke werkstations of laptops
• Eenvoud en gebruiksgemak prioriteiten zijn

Veel teams gebruiken beide: Ollama voor ontwikkeling en experimentatie, en vLLM voor productiedeployment. Deze combinatie biedt ontwikkelaarproductiviteit terwijl productieprestaties worden behouden.

vLLM vs Docker Model Runner

Docker heeft onlangs Model Runner (voorheen GenAI Stack) geïntroduceerd als hun officiële oplossing voor lokale AI-modeldeployments. Hoe vergelijkt het met vLLM?

Architectuur Filosofie

Docker Model Runner streeft ernaar de “Docker voor AI” te zijn – een simpele, gestandaardiseerde manier om AI-modellen lokaal te draaien met dezelfde eenvoud als het draaien van containers. Het abstrahereert complexiteit en biedt een consistente interface over verschillende modellen en frameworks.

vLLM is een gespecialiseerde inference engine gefocust uitsluitend op LLM serving met maximale prestaties. Het is een lagerniveau tool die u containeriseert met Docker, in plaats van een compleet platform.

Setup en Aan de Slag

Docker Model Runner installatie is rechttoe rechtan voor Docker gebruikers:

docker model pull llama3:8b
docker model run llama3:8b

Deze gelijkenis met Docker’s image workflow maakt het direct vertrouwd voor ontwikkelaars die al containers gebruiken.

vLLM vereist meer initiële setup (Python, CUDA, afhankelijkheden) of het gebruik van pre-built Docker images:

docker pull vllm/vllm-openai:latest
docker run --runtime nvidia --gpus all vllm/vllm-openai:latest --model <model-naam>

Prestatiekarakteristieken

vLLM levert superieure doorvoer voor multi-user scenario’s dankzij PagedAttention en continue batching. Voor productiediensten die honderden requests per seconde verwerken, bieden vLLM’s optimalisaties 2-5 keer betere doorvoer dan generieke servingbenaderingen.

Docker Model Runner focust op gebruiksgemak in plaats van maximale prestaties. Het is geschikt voor lokale ontwikkeling, testen en gematigde lasten, maar implementeert niet de geavanceerde optimalisaties die vLLM laten uitblinken bij schaal.

Modelondersteuning

Docker Model Runner biedt een gecureerde modelbibliotheek met één-commando toegang tot populaire modellen. Het ondersteunt meerdere frameworks (niet alleen LLM’s) waaronder Stable Diffusion, Whisper en andere AI-modellen, waardoor het veelzijdiger is voor verschillende AI-lasten.

vLLM specialiseert zich in LLM inference met diepe ondersteuning voor transformer-based taalmodellen. Het ondersteunt elk HuggingFace-compatibel LLM, maar strekt zich niet uit naar andere AI-modeltypen zoals beeldgeneratie of spraakherkenning.

Productiedeployment

vLLM is getest in productie bij bedrijven zoals Anthropic, Replicate, en vele anderen die dagelijks miljarden tokens serveren. Zijn prestatiekarakteristieken en stabiliteit onder zware last maken het de de facto standaard voor productieve LLM-serving.

Docker Model Runner is nieuwere en positioneert zich meer voor ontwikkeling en lokale testscenario’s. Hoewel het productieverkeer kan serveren, mist het het bewezen trackrecord en prestatieoptimalisaties die productiedeployments vereisen.

Integratie Ecosysteem

vLLM integreert met productiestructuurtools: Kubernetes operators, Prometheus metrics, Ray voor gedistribueerde serving, en uitgebreide OpenAI API compatibiliteit voor bestaande applicaties.

Docker Model Runner integreert natuurlijk met Docker’s ecosysteem en Docker Desktop. Voor teams die al gestandaardiseerd zijn op Docker, biedt deze integratie een cohesieve ervaring maar minder gespecialiseerde LLM-servingfuncties.

Wanneer Elk Te Gebruiken

Gebruik vLLM voor:

• Productie LLM API diensten
• Hoge doorvoer, multi-user deployments
• Kostenbewuste clouddeployments die maximale efficiëntie nodig hebben
• Kubernetes en cloud-native omgevingen
• Wanneer u bewezen schaalbaarheid en prestaties nodig heeft

Gebruik Docker Model Runner voor:

• Lokale ontwikkeling en testen
• Het draaien van verschillende AI-modeltypen (niet alleen LLM’s)
• Teams die zwaar geïnvesteerd zijn in het Docker ecosysteem
• Snelle experimentatie zonder infrastructuuropzet
• Leer- en educatieve doeleinden

Hybride Aanpak: Veel teams ontwikkelen met Docker Model Runner lokaal voor gemak, en deployen vervolgens met vLLM in productie voor prestaties. De Docker Model Runner images kunnen ook worden gebruikt om vLLM containers te draaien, waardoor beide benaderingen worden gecombineerd.

Beste Praktijken voor Productiedeployment

Docker Deployment

Maak een productieready Docker Compose configuratie:

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    environment:
      - CUDA_VISIBLE_DEVICES=0,1
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --tensor-parallel-size 2
      --gpu-memory-utilization 0.90
      --max-num-seqs 256
      --max-model-len 8192      
    restart: unless-stopped
    shm_size: '16gb'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

Kubernetes Deployment

Deploy vLLM op Kubernetes voor productieschaal:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.2
          - --tensor-parallel-size
          - "2"
          - --gpu-memory-utilization
          - "0.90"
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: cache
        hostPath:
          path: /mnt/huggingface-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Monitoring en Observability

vLLM stelt Prometheus metrics bloot voor monitoring:

import requests

# Haal metrics op
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

Belangrijke metrics om te monitoren:

• vllm:num_requests_running - Actieve requests
• vllm:gpu_cache_usage_perc - KV cache utilisatie
• vllm:time_to_first_token - Latentie metric
• vllm:time_per_output_token - Generatiesnelheid

Prestatie Tuning

Optimaliseer GPU Geheugen Utilisatie: Begin met --gpu-memory-utilization 0.90 en pas aan op basis van waargenomen gedrag. Hogere waarden laten grotere batches toe, maar riskeren OOM-fouten tijdens verkeerpieken.

Tune Max Sequence Lengte: Als uw use case niet de volledige contextlengte nodig heeft, verlaag dan --max-model-len. Dit vrijt geheugen voor grotere batches. Bijvoorbeeld, als u alleen 4K context nodig heeft, stel dan --max-model-len 4096 in in plaats van het model’s maximum (vaak 8K-32K).

Kies Geschikte Kwantificatie: Voor modellen die het ondersteunen, gebruik gekwantificeerde versies (8-bit, 4-bit) om geheugen te verminderen en doorvoer te verhogen:

--quantization awq  # Voor AWQ gekwantificeerde modellen
--quantization gptq # Voor GPTQ gekwantificeerde modellen

Activeer Prefix Caching: Voor applicaties met herhaalde prompts (zoals chatbots met systeemberichten), activeer prefix caching:

--enable-prefix-caching

Dit cacheert de KV waarden voor veelvoorkomende prefixes, wat berekening vermindert voor requests die dezelfde prompt prefix delen.

Veelvoorkomende Problemen Oplossen

Out of Memory Fouten

Symptomen: Server crasht met CUDA out of memory fouten.

Oplossingen:

• Verminder --gpu-memory-utilization naar 0.85 of 0.80
• Verminder --max-model-len als uw use case dit toelaat
• Verlaag --max-num-seqs om batchgrootte te verkleinen
• Gebruik een gekwantificeerde modelversie
• Activeer tensor parallelisme om over meer GPU’s te verdelen

Lage Doorvoer

Symptomen: Server verwerkt minder requests dan verwacht.

Oplossingen:

• Verhoog --max-num-seqs om grotere batches toe te staan
• Verhoog --gpu-memory-utilization als u ruimte heeft
• Controleer of CPU de bottleneck is met htop – overweeg snellere CPU’s
• Verifieer GPU utilisatie met nvidia-smi – zou 95%+ moeten zijn
• Activeer FP16 als u FP32 gebruikt: --dtype float16

Langzame Eerste Token Tijd

Symptomen: Hoge latentie voordat generatie begint.

Oplossingen:

• Gebruik kleinere modellen voor latentie-kritieke applicaties
• Activeer prefix caching voor herhaalde prompts
• Verminder --max-num-seqs om latentie boven doorvoer te prioriteren
• Overweeg speculative decoding voor ondersteunde modellen
• Optimaliseer tensor parallelisme configuratie

Model Laden Mislukt

Symptomen: Server start niet, kan model niet laden.

Oplossingen:

• Verifieer dat modelnaam exact overeenkomt met HuggingFace formaat
• Controleer netwerkconnectiviteit naar HuggingFace Hub
• Zorg voor voldoende schijfruimte in ~/.cache/huggingface
• Voor gated modellen, stel HF_TOKEN environment variabele in
• Probeer handmatig te downloaden met huggingface-cli download <model>

Geavanceerde Functies

Speculative Decoding

vLLM ondersteunt speculative decoding, waarbij een kleiner draft-model tokens voorstelt die een groter target-model verifieert. Dit kan generatie versnellen met 1.5-2x:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-70b-chat-hf \
    --speculative-model meta-llama/Llama-2-7b-chat-hf \
    --num-speculative-tokens 5

LoRA Adapters

Serveer meerdere LoRA adapters bovenop een basismodel zonder meerdere volledige modellen te laden:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-hf \
    --enable-lora \
    --lora-modules sql-lora=./path/to/sql-adapter \
                   code-lora=./path/to/code-adapter

Specificeer vervolgens welke adapter per request te gebruiken:

response = client.completions.create(
    model="sql-lora",  # Gebruik de SQL adapter
    prompt="Converteer dit naar SQL: Toon alle gebruikers aangemaakt deze maand"
)

Multi-LoRA Serving

vLLM’s multi-LoRA serving maakt het hosten van tientallen fine-tuned adapters mogelijk met minimale geheugenoverhead. Dit is ideaal voor het serveren van klant-specifieke of taak-specifieke modelvarianten:

# Request met specifieke LoRA adapter
response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[{"role": "user", "content": "Schrijf SQL query"}],
    extra_body={"lora_name": "sql-lora"}
)

Prefix Caching

Activeer automatisch prefix caching om herberekening van KV cache voor herhaalde prompt prefixes te vermijden:

--enable-prefix-caching

Dit is vooral effectief voor:

• Chatbots met vaste systeemprompts
• RAG applicaties met consistente context templates
• Few-shot learning prompts die herhaald worden over requests

Prefix caching kan time-to-first-token verminderen met 50-80% voor requests die prompt prefixes delen.

Integratie Voorbeelden

LangChain Integratie

from langchain.llms import VLLMOpenAI

llm = VLLMOpenAI(
    openai_api_key="EMPTY",
    openai_api_base="http://localhost:8000/v1",
    model_name="mistralai/Mistral-7B-Instruct-v0.2",
    max_tokens=512,
    temperature=0.7,
)

response = llm("Leg PagedAttention uit in simpele termen")
print(response)

LlamaIndex Integratie

from llama_index.llms import VLLMServer

llm = VLLMServer(
    api_url="http://localhost:8000/v1",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    temperature=0.7,
    max_tokens=512
)

response = llm.complete("Wat is vLLM?")
print(response)

FastAPI Applicatie

from fastapi import FastAPI
from openai import AsyncOpenAI

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

@app.post("/generate")
async def generate(prompt: str):
    response = await client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.2",
        prompt=prompt,
        max_tokens=200
    )
    return {"result": response.choices[0].text}

Prestatie Benchmarks

Realistische prestatiegegevens helpen vLLM’s voordelen illustreren:

Doorvoer Vergelijking (Mistral-7B op A100 GPU):

• vLLM: ~3.500 tokens/second met 64 gelijktijdige gebruikers
• HuggingFace Transformers: ~250 tokens/second met dezelfde concurrentie
• Ollama: ~1.200 tokens/second met dezelfde concurrentie
• Resultaat: vLLM biedt 14x verbetering boven basisimplementaties

Geheugenefficiëntie (LLaMA-2-13B):

• Standaard implementatie: 24GB VRAM, 32 gelijktijdige sequenties
• vLLM met PagedAttention: 24GB VRAM, 128 gelijktijdige sequenties
• Resultaat: 4x meer gelijktijdige requests met hetzelfde geheugen

Latentie onder Belasting (Mixtral-8x7B op 2xA100):

• vLLM: P50 latentie 180ms, P99 latentie 420ms bij 100 req/s
• Standaard serving: P50 latentie 650ms, P99 latentie 3.200ms bij 100 req/s
• Resultaat: vLLM handhaaft consistente latentie onder hoge last

Deze benchmarks demonstreren waarom vLLM de de facto standaard is geworden voor productieve LLM-serving waar prestaties tellen.

Kostenanalyse

Begrip van de kostenimplicaties van het kiezen van vLLM:

Scenario: 1M requests/dag serveren

Met Standaard Serving:

• Vereist: 8x A100 GPU’s (80GB)
• AWS kosten: ~$32/uur × 24 × 30 = $23.040/maand
• Kosten per 1M tokens: ~$0,75

Met vLLM:

• Vereist: 2x A100 GPU’s (80GB)
• AWS kosten: ~$8/uur × 24 × 30 = $5.760/maand
• Kosten per 1M tokens: ~$0,19
• Besparing: $17.280/maand (75% reductie)

Dit kostenvoordeel groeit met schaal. Organisaties die miljarden tokens maandelijks serveren, sparen honderdduizenden dollars door gebruik te maken van vLLM’s geoptimaliseerde serving in plaats van naïeve implementaties.

Veiligheidsoverwegingen

Authenticatie

vLLM bevat geen authenticatie standaard. Voor productie, implementeer authenticatie op het reverse proxy niveau:

# Nginx configuratie
location /v1/ {
    auth_request /auth;
    proxy_pass http://vllm-backend:8000;
}

location /auth {
    proxy_pass http://auth-service:8080/verify;
    proxy_pass_request_body off;
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

Of gebruik API gateways zoals Kong, Traefik, of AWS API Gateway voor enterprise-grade authenticatie en rate limiting.

Netwerk Isolatie

Draai vLLM in privénetwerken, niet direct blootgesteld aan het internet:

# Kubernetes NetworkPolicy voorbeeld
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: vllm-access
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: api-gateway
    ports:
    - protocol: TCP
      port: 8000

Rate Limiting

Implementeer rate limiting om misbruik te voorkomen:

# Voorbeeld met Redis voor rate limiting
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import redis
from datetime import datetime, timedelta

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.middleware("http")
async def rate_limit_middleware(request, call_next):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"
    
    requests = redis_client.incr(key)
    if requests == 1:
        redis_client.expire(key, 60)  # 60 seconden venster
    
    if requests > 60:  # 60 requests per minuut
        raise HTTPException(status_code=429, detail="Rate limit overschreden")
    
    return await call_next(request)

Model Toegang Beheer

Voor multi-tenant deployments, controleer welke gebruikers toegang hebben tot welke modellen:

TOEGESTANDE_MODellen = {
    "user_tier_1": ["mistralai/Mistral-7B-Instruct-v0.2"],
    "user_tier_2": ["mistralai/Mistral-7B-Instruct-v0.2", "meta-llama/Llama-2-13b-chat-hf"],
    "admin": ["*"]  # Alle modellen
}

def verify_model_toegang(user_tier: str, model: str) -> bool:
    toegestaan = TOEGESTANDE_MODellen.get(user_tier, [])
    return "*" in toegestaan or model in toegestaan

Migratie Gids

Van OpenAI naar vLLM

Migratie van OpenAI naar zelf-gehoste vLLM is eenvoudig dankzij API compatibiliteit:

Voorheen (OpenAI):

from openai import OpenAI

client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hallo"}]
)

Na (vLLM):

from openai import OpenAI

client = OpenAI(
    base_url="https://your-vllm-server.com/v1",
    api_key="your-internal-key"  # Als u authenticatie hebt toegevoegd
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Hallo"}]
)

Slechts twee veranderingen nodig: update base_url en model naam. Alle andere code blijft identiek.

Van Ollama naar vLLM

Ollama gebruikt een ander API formaat. Hier is de conversie:

Ollama API:

import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'llama2',
        'prompt': 'Waarom is de lucht blauw?'
    })

vLLM Equivalent:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.completions.create(
    model="meta-llama/Llama-2-7b-chat-hf",
    prompt="Waarom is de lucht blauw?"
)

U zult API calls in uw codebase moeten updaten, maar de OpenAI client bibliotheken bieden betere foutafhandeling en functies.

Van HuggingFace Transformers naar vLLM

Directe Python gebruik migratie:

HuggingFace:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

inputs = tokenizer("Hallo", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])

vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.2")
sampling_params = SamplingParams(max_tokens=100)

outputs = llm.generate("Hallo", sampling_params)
result = outputs[0].outputs[0].text

vLLM’s Python API is eenvoudiger en veel sneller voor batch inference.

Toekomst van vLLM

vLLM blijft snelle ontwikkeling doorgaan met opwindende functies op de roadmap:

Gedissosieerde Serving: Scheiding van prefill (prompt verwerking) en decode (token generatie) naar verschillende GPU’s om resource utilisatie te optimaliseren. Prefill is compute-bound terwijl decode memory-bound is, dus het uitvoeren ervan op gespecialiseerde hardware verbetert efficiëntie.

Multi-Node Inference: Verdelen van zeer grote modellen (100B+ parameters) over meerdere machines, waardoor het serveren van modellen mogelijk wordt die te groot zijn voor single-node setups.

Verbeterde Kwantificatie: Ondersteuning voor nieuwe kwantificatie formats zoals GGUF (gebruikt door llama.cpp) en verbeterde AWQ/GPTQ integratie voor betere prestaties met gekwantificeerde modellen.

Speculative Decoding Verbeteringen: Efficiëntere draft modellen en adaptieve speculatie strategieën om hogere snelheidsverhogingen te bereiken zonder nauwkeurheidsverlies.

Attention Optimalisaties: FlashAttention 3, ring attention voor extreem lange contexten (100K+ tokens), en andere cutting-edge attention mechanismen.

Betere Modeldekking: Uitbreiding van ondersteuning naar multimodale modellen (vision-language modellen), audio modellen en gespecialiseerde architecturen zoals ze ontstaan.

Het vLLM project onderhoudt actieve ontwikkeling met bijdragen van UC Berkeley, Anyscale, en de bredere open-source community. Zoals LLM deployment steeds kritieker wordt voor productiesystemen, blijft vLLM’s rol als prestatiestandaard groeien. Voor een bredere vergelijking van vLLM met andere lokale en cloud LLM infrastructuur, bekijk onze LLM Hosting: Lokaal, Zelf-Gehost & Cloud Infrastructuur Vergelijk.

Nuttige Links

Gerelateerde Artikelen op Deze Site

• Lokale LLM Hosting: Volledige 2026 Gids - Ollama, vLLM, LocalAI, Jan, LM Studio & Meer - Uitgebreide vergelijking van 12+ lokale LLM hosting tools inclusief gedetailleerde vLLM analyse naast Ollama, LocalAI, Jan, LM Studio en anderen. Dekkt API rijpheid, tool calling ondersteuning, GGUF compatibiliteit en prestatiebenchmarks om de juiste oplossing te kiezen.

• Ollama Cheatsheet - Complete Ollama commandoreferentie en cheatsheet die installatie, model beheer, API gebruik en beste praktijken voor lokale LLM deployment bestrijkt. Essentieel voor ontwikkelaars die Ollama gebruiken naast of in plaats van vLLM.

• llama.cpp Snelstart met CLI en Server - Lichtgewicht C/C++ inference voor GGUF-modellen met llama-cli en OpenAI-compatibele llama-server. Ideaal wanneer u fijngedetailleerde controle, offline deployment of een minimale stack zonder Python nodig heeft.

• Docker Model Runner vs Ollama: Wat te Kiezen? - Diepgaande vergelijking van Docker’s Model Runner en Ollama voor lokale LLM deployment, analyseert prestaties, GPU ondersteuning, API compatibiliteit en use cases. Helpt het competitieve landschap begrijpen waarin vLLM opereert.

• Docker Model Runner Cheatsheet: Commands & Voorbeelden - Praktische Docker Model Runner cheatsheet met commands en voorbeelden voor AI model deployment. Handig voor teams die Docker’s aanpak vergelijken met vLLM’s gespecialiseerde LLM serving mogelijkheden.

Externe Bronnen en Documentatie

• vLLM GitHub Repository - Officieel vLLM repository met broncode, uitgebreide documentatie, installatiegidsen, en actieve community discussies. Essentiële bron om actueel te blijven met nieuwste functies en het oplossen van problemen.

• vLLM Documentatie - Officiële documentatie die alle aspecten van vLLM bestrijkt van basissetup tot geavanceerde configuratie. Inclusief API referenties, prestatie tuning gidsen, en deployment beste praktijken.

• PagedAttention Paper - Academisch papier dat het PagedAttention algoritme introduceert dat vLLM’s efficiëntie aandrijft. Essentiële lectuur voor het begrijpen van de technische innovaties achter vLLM’s prestatievoordelen.

• vLLM Blog - Officieel vLLM blog met release aankondigingen, prestatiebenchmarks, technische diepgangen, en community casestudies van productiedeployments.

• HuggingFace Model Hub - Uitgebreide repository van open-source LLM’s die werken met vLLM. Zoek naar modellen op grootte, taak, licentie, en prestatiekarakteristieken om het juiste model voor uw use case te vinden.

• Ray Serve Documentatie - Ray Serve framework documentatie voor het bouwen van schaalbare, gedistribueerde vLLM deployments. Ray biedt geavanceerde functies zoals autoscaling, multi-model serving, en resourcebeheer voor productiesystemen.

• NVIDIA TensorRT-LLM - NVIDIA’s TensorRT-LLM voor highly geoptimaliseerde inference op NVIDIA GPU’s. Alternatief voor vLLM met verschillende optimalisatiestrategieën, handig voor vergelijking en het begrijpen van de inference optimalisatie landschap.

• OpenAI API Referentie - Officiële OpenAI API documentatie waarmee vLLM’s API compatibel is. Referentie dit bij het bouwen van applicaties die moeten werken met zowel OpenAI als zelf-gehoste vLLM endpoints wisselend.