vLLM Quickstart: High-Performance LLM Serving - in 2026

vLLM is een hoogdoorlopende, geheugen-efficiënte engine voor het uitvoeren en serveren van grote taalmodellen (LLMs) ontwikkeld door het Sky Computing Lab van de Universiteit van Californië, Berkeley.

Met zijn revolutie-gevende PagedAttention-algoritme bereikt vLLM een doorloopvermogen dat 14-24 keer hoger is dan bij traditionele servermethoden, waardoor het de voorkeur heeft bij productie-LLM-implementaties. Om te zien hoe vLLM past bij Ollama, Docker Model Runner, LocalAI en cloudproviders—waaronder kosten- en infrastructuurcompromissen—zie LLM Hosting: Local, Self-Hosted & Cloud Infrastructure Compared.

Wat is vLLM?

vLLM (virtueel LLM) is een open-source bibliotheek voor snelle LLM-inferentie en serveren die snel de industrie-standaard geworden is voor productieimplementaties. Uitgegeven in 2023, introduceerde het PagedAttention, een doorbraak in geheugenbeheer die de efficiëntie van het serveren aanzienlijk verbetert.

Belangrijke kenmerken

Hoog doorloopvermogen: vLLM levert 14-24 keer hoger doorloopvermogen dan HuggingFace Transformers met dezelfde hardware. Deze grote prestatiegain komt voort uit continue batchverwerking, geoptimaliseerde CUDA-kernels en het PagedAttention-algoritme dat geheugenfragmentatie elimineert.

OpenAI API-compatibiliteit: vLLM bevat een ingebouwde API-server die volledig compatibel is met de OpenAI-indeling. Dit stelt een soepele migratie van OpenAI naar zelfgehoste infrastructuur mogelijk zonder wijzigingen in de toepassingscode. Stel eenvoudig uw API-client in op vLLM’s eindpunt en het werkt transparant.

PagedAttention-algoritme: Het kerninnovatie van vLLM’s prestaties is PagedAttention, dat het concept virtuele geheugenpagina’s toepast op aandachtmechanismen. In plaats van contige geheugenblokken te alloqueren voor KV-caches (wat leidt tot fragmentatie), verdeelt PagedAttention geheugen in vaste grootteblokken die op aanvraag kunnen worden toegewezen. Dit vermindert geheugenverlies tot 4 keer en stelt veel grotere batchgrootte mogelijk.

Continue batchverwerking: In tegenstelling tot statische batchverwerking waarbij je moet wachten tot alle sequenties voltooid zijn, gebruikt vLLM continue (rolleende) batchverwerking. Zodra één sequentie voltooid is, kan er een nieuwe aan de batch worden toegevoegd. Dit maximaliseert GPU-gebruik en minimaliseert latentie voor aankomende aanvragen.

Multi-GPU-ondersteuning: vLLM ondersteunt tensorparallelisme en pipelineparallelisme voor het verdelen van grote modellen over meerdere GPUs. Het kan efficiënt modellen serveren die niet in het geheugen van één GPU passen, met configuraties van 2 tot 8+ GPUs.

Breed modelondersteuning: compatibel met populaire modelarchitecturen zoals LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma en veel meer. Ondersteunt zowel instructie-aangepaste als basismodellen van HuggingFace Hub.

Wanneer vLLM gebruiken

vLLM excelleert in specifieke scenario’s waar zijn sterktes schijnen:

Productie-API-diensten: Wanneer je een LLM moet serveren aan veel gelijktijdige gebruikers via API, is vLLM’s hoge doorloopvermogen en efficiënte batchverwerking de beste keuze. Bedrijven die chatbots, code-assistenten of inhoudsgeneratie-diensten draaien, profiteren van zijn vermogen om honderden aanvragen per seconde te verwerken.

Hoge-concurrentiebelastingen: Als je applicatie veel gelijktijdige gebruikers heeft die aanvragen doen, stelt vLLM’s continue batchverwerking en PagedAttention in staat om meer gebruikers met dezelfde hardware te serveren dan alternatieven.

Kostenefficiëntie: Wanneer GPU-kosten een zorg zijn, betekent vLLM’s superieure doorloopvermogen dat je dezelfde verkeer kunt serveren met minder GPUs, wat de infrastructuurkosten direct verlaagt. De 4x geheugen-efficiëntie van PagedAttention stelt ook het gebruik van kleinere, goedkoper GPU-instellingen mogelijk.

Kubernetes-implementaties: vLLM’s stateless ontwerp en containervriendelijke architectuur maken het ideaal voor Kubernetes-clusters. Zijn consistentie onder belasting en eenvoudige resourcebeheer integreren goed met cloud-native infrastructuur.

Wanneer vLLM niet gebruiken: Voor lokale ontwikkeling, experimenten of enkelgebruikersscenario’s, bieden tools zoals Ollama een betere gebruikerservaring met eenvoudigere installatie. De complexiteit van vLLM is gerechtvaardigd wanneer je zijn prestatievoordelen nodig hebt voor productiebelastingen.

Hoe vLLM installeren

Voorwaarden

Voordat je vLLM installeert, zorg er dan voor dat je systeem 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 16 GB voor 7B-modellen, 24 GB+ voor 13B, 40 GB+ voor grotere modellen
• Driver: NVIDIA driver 450.80.02 of nieuer

Installatie via pip

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

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

# Installeer vLLM
pip install vllm

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

Voor systemen met andere CUDA-versies, installeer het passende 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 implementatiemethode, vooral voor productie:

# Trek het officiële vLLM-image op
docker pull vllm/vllm-openai:latest

# Start 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-vlag is belangrijk voor multi-GPU-setup omdat het juiste interprocesscommunicatie mogelijk maakt.

Bouwen vanuit bron

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

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

Snelstartgids voor vLLM

Je 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 HuggingFace Hub (indien niet gecached) en de server starten. Je ziet uitvoer die aangeeft dat de server gereed 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-aanvragen maken

Zodra de server draait, kun je aanvragen doen via 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

# Stel in op je 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 veel 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 de GPU-geheugen
    --max-model-len 8192 \            # Maximaal sequentielengte
    --tensor-parallel-size 2 \        # Gebruik 2 GPUs met tensorparallelisme
    --dtype float16 \                 # Gebruik FP16-precisie
    --max-num-seqs 256                # Maximaal aantal sequenties

Belangrijke parameters uitgelegd:

• --gpu-memory-utilization: Hoeveel GPU-geheugen te gebruiken (0.90 = 90%). Hogere waarden laten grotere batches toe maar laten minder ruimte voor geheugenpieken.
• --max-model-len: Maximaal contextlengte. Verminderen spartelt geheugen voor grotere batches.
• --tensor-parallel-size: Aantal GPUs om het model over te verdelen.
• --dtype: Gegevenstype voor gewichten (float16, bfloat16 of float32). FP16 is meestal ideaal.
• --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 toepassingsgebieden. Begrijpen wanneer je elk gereedschap gebruikt kan aanzienlijk invloed hebben op het succes van je project.

Prestaties en doorloopvermogen

vLLM is ontworpen voor maximale doorloopvermogen in meergebruikersscenario’s. Zijn PagedAttention en continue batchverwerking maken het mogelijk om honderden gelijktijdige aanvragen efficiënt te verwerken. Benchmarks tonen aan dat vLLM 14-24 keer hoger doorloopvermogen bereikt dan standaardimplementaties en 2-4 keer hoger dan Ollama onder hoge concurrentie.

Ollama optimaliseert voor enkelgebruikersinteractieve gebruik met focus op lage latentie voor individuele aanvragen. Hoewel het niet overtreft vLLM’s meergebruikersdoorloopvermogen, biedt het uitstekende prestaties voor ontwikkeling en persoonlijk gebruik met snellere koudstarttijden en lagere rustresourceverbruik.

Gebruiksgemak

Ollama wint beslissend op eenvoud. Installatie is één commando (curl | sh), en het draaien van modellen is net zo eenvoudig als ollama run llama2. Het bevat een modelbibliotheek met gequantiseerde versies die zijn afgestemd op verschillende hardwareprofielen. De gebruikerservaring lijkt op Docker – trek, draai en ga.

vLLM vereist meer setup: Python-omgevingsbeheer, CUDA-installatie, begrip van serverparameters en handmatige modelopgave. De leercurve is steiler, maar je krijgt fijngevoelige controle over prestatieoptimalisatie. Deze complexiteit is gerechtvaardigd voor productieimplementaties waar je maximale prestaties moet trekken uit je hardware.

API en integratie

vLLM biedt standaard OpenAI-compatibele REST-Api’s, waardoor het een directe vervanging is voor OpenAI’s API in bestaande toepassingen. Dit is cruciaal voor het migreren van productiediensten van cloudproviders naar zelfgehoste infrastructuur zonder codeveranderingen.

Ollama biedt een eenvoudigere REST-Api en een toegewijde Python/JavaScript-bibliotheek. Hoewel functioneel, is het niet OpenAI-compatibel, wat codeveranderingen vereist bij integratie met toepassingen die OpenAI’s indeling verwachten. Echter, communityprojecten zoals Ollama-OpenAI adapters vullen deze kloof.

Geheugenbeheer

vLLM’s PagedAttention-algoritme biedt superieure geheugen-efficiëntie voor gelijktijdige aanvragen. Het kan 2-4 keer meer gelijktijdige gebruikers dienen met hetzelfde VRAM in vergelijking met naïeve implementaties. Dit vertaalt direct in kostensparing in productieimplementaties.

Ollama gebruikt eenvoudiger geheugenbeheer dat geschikt is voor enkelgebruikersscenario’s. Het beheert automatisch het laden/ontladen van modellen op basis van activiteit, wat handig is voor ontwikkeling maar niet ideaal voor hoge-concurrentieproductiegebruik.

Multi-GPU-ondersteuning

vLLM excelleert met native tensorparallelisme en pipelineparallelisme, efficiënt verdelen van modellen over 2-8+ GPUs. Dit is essentieel voor het serveren van grote modellen zoals 70B parameter LLMs die niet in één GPU passen.

Ollama heeft beperkte multi-GPU-ondersteuning, werkt vooral het beste met één GPU. Dit maakt het minder geschikt voor zeer grote modellen die gedistribueerde inferentie vereisen.

Gebruiksscenario aanbevelingen

Kies vLLM wanneer:

• Je productie-API’s moet dienen aan veel gelijktijdige gebruikers
• Je kosten per aanvraag in cloudimplementaties moet optimaliseren
• Je in Kubernetes of containerorchestratieplatforms draait
• Je OpenAI API-compatibiliteit nodig hebt voor bestaande toepassingen
• Je grote modellen moet serveren die multi-GPU-ondersteuning vereisen
• Prestaties en doorloopvermogen kritieke eisen zijn

Kies Ollama wanneer:

• Je lokale ontwikkeling en experimenten doet
• Je enkelgebruikersinteractieve gebruik (persoonlijke assistenten, chatbots)
• Je snelle prototyping en modelbeoordeling wil
• Je leert over LLMs zonder infrastructuurcomplexiteit
• Je op persoonlijke werkstations of laptops draait
• Eenvoud en gebruiksgemak prioriteiten zijn

Veel teams gebruiken beide: Ollama voor ontwikkeling en experimenten, dan vLLM voor productieimplementatie. Deze combinatie biedt ontwikkelaarsproductiviteit terwijl productieprestaties worden behouden.

vLLM vs Docker Model Runner

Docker heeft recent Model Runner (vormerlijk GenAI Stack) ingevoerd als hun officiële oplossing voor lokale AI-modelimplementatie. Hoe vergelijkt het zich met vLLM?

Architectuurfilosofie

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

vLLM is een gespecialiseerde inferentie-engine gericht op LLM-serveren met maximale prestaties. Het is een lagere-laag gereedschap dat je containerise met Docker, in plaats van een volledig platform.

Setup en aan de slag

Docker Model Runner installatie is eenvoudig 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 vooraf gebouwde Docker-images:

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

Prestatiekenmerken

vLLM levert superieure doorloopvermogen voor meergebruikersscenario’s dankzij PagedAttention en continue batchverwerking. Voor productie-API-diensten die honderden aanvragen per seconde verwerken, bieden vLLM’s optimalisaties 2-5 keer betere doorloopvermogen dan generieke servermethoden.

Docker Model Runner richt zich op gemak van gebruik in plaats van maximale prestaties. Het is geschikt voor lokale ontwikkeling, testen en matige belastingen, maar implementeert geen geavanceerde optimalisaties die vLLM uitmaken voor schaal.

Modelondersteuning

Docker Model Runner biedt een gecurateerde modelbibliotheek met één-commando toegang tot populaire modellen. Het ondersteunt meerdere frameworks (niet alleen LLMs) inclusief Stable Diffusion, Whisper en andere AI-modellen, waardoor het meer geschikt is voor verschillende AI-belastingen.

vLLM specialiseert zich in LLM-inferentie met diepe ondersteuning voor transformergebaseerde taalmodellen. Het ondersteunt elk HuggingFace-compatibel LLM, maar stelt geen uitbreiding tot andere AI-modeltypes zoals beeldgeneratie of spraakherkenning.

Productieimplementatie

vLLM is getest in productie bij bedrijven zoals Anthropic, Replicate en veel andere die dagelijks miljarden tokens serveren. Zijn prestatiekenmerken en stabiliteit onder zware belasting maken het de standaard voor productie LLM-serveren.

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

Integratieecosysteem

vLLM integreert met productieinfrastructuurtools: Kubernetes operators, Prometheus metrieken, Ray voor gedistribueerde serveren en uitgebreide OpenAI API-compatibiliteit voor bestaande toepassingen.

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

Wanneer elk te gebruiken

Gebruik vLLM voor:

• Productie LLM API-diensten
• Hoge-doorloopvermogen, meergebruikersimplementaties
• Kostenefficiënte cloudimplementaties die maximale efficiëntie vereisen
• Kubernetes en cloud-native omgevingen
• Wanneer je bewezen schaalbaarheid en prestaties nodig hebt

Gebruik Docker Model Runner voor:

• Lokale ontwikkeling en testen
• Het draaien van verschillende AI-modeltypes (niet alleen LLMs)
• Teams die zwaar investeren in Docker-ecosysteem
• Snel experimenten zonder infrastructuursetup
• Leer- en educatieve doeleinden

Hybride aanpak: Veel teams ontwikkelen met Docker Model Runner lokaal voor gemak, dan implementeren met vLLM in productie voor prestaties. De Docker Model Runner images kunnen ook worden gebruikt om vLLM-containers te draaien, waarmee beide aanpakken worden gecombineerd.

Beste praktijken voor productieimplementatie

Docker-implementatie

Maak een productieklaar Docker Compose-configuratiebestand:

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-implementatie

Implementeer 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 observabiliteit

vLLM biedt Prometheus metrieken voor monitoring:

import requests

# Ophalen van metrieken
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

Belangrijke metrieken om te monitoren:

• vllm:num_requests_running - Actieve aanvragen
• vllm:gpu_cache_usage_perc - Gebruik van KV-cache
• vllm:time_to_first_token - Latentie-metriek
• vllm:time_per_output_token - Snelheid van generatie

Prestatieoptimalisatie

Optimaliseer GPU-geheugenutilisatie: Start met --gpu-memory-utilization 0.90 en pas aan op basis van waargenomen gedrag. Hogere waarden laten grotere batches toe maar lopen het risico op OOM-fouten tijdens verkeerspieken.

Stel maximaal sequentielengte in: Als je gebruikscasus geen volledige contextlengte nodig heeft, verminder --max-model-len. Dit vrijmaakt geheugen voor grotere batches. Bijvoorbeeld, als je alleen 4K context nodig hebt, stel --max-model-len 4096 in in plaats van de modelmaximum (vaak 8K-32K).

Kies geschikte quantisatie: Voor modellen die dat ondersteunen, gebruik gequantiseerde versies (8-bit, 4-bit) om geheugen te verminderen en doorloopvermogen te verhogen:

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

Schakel prefixcaching in: Voor toepassingen met herhalende prompts (zoals chatbots met systeemmeldingen), schakel prefixcaching in:

--enable-prefix-caching

Dit cache de KV-waarden voor veelvoorkomende voorvoegsels, waardoor berekening wordt verminderd voor aanvragen met hetzelfde promptvoorvoegsel.

Probleemoplossing voor veelvoorkomende problemen

Geheugenfouten

Symptomen: Server crash met CUDA-geheugenfouten.

Oplossingen:

• Verminder --gpu-memory-utilization naar 0.85 of 0.80
• Verminder --max-model-len als je gebruikscasus dat toelaat
• Verminder --max-num-seqs om batchgrootte te verminderen
• Gebruik een gequantiseerde modelversie
• Schakel tensorparallelisme in om over meer GPUs te verdelen

Lage doorloopvermogen

Symptomen: Server verwerkt minder aanvragen dan verwacht.

Oplossingen:

• Verhoog --max-num-seqs om grotere batches toe te staan
• Verhoog --gpu-memory-utilization als je ruimte hebt
• Controleer of CPU bottleneck is met htop – overweeg snellere CPUs
• Controleer GPU-gebruik met nvidia-smi – moet 95%+ zijn
• Schakel FP16 in als je FP32 gebruikt: --dtype float16

Snelheid van eerste token

Symptomen: Hoge latentie voor het begin van de generatie.

Oplossingen:

• Gebruik kleinere modellen voor latency-critische toepassingen
• Schakel prefixcaching in voor herhalende prompts
• Verminder --max-num-seqs om prioriteit te geven aan latentie boven doorloopvermogen
• Overweeg speculatieve decoding voor ondersteunde modellen
• Optimaliseer tensorparallelismeconfiguratie

Model Laden fouten

Symptomen: Server kan niet starten, model kan niet worden geladen.

Oplossingen:

• Controleer of modelnaam exact overeenkomt met HuggingFace-indeling
• Controleer netwerkverbinding met HuggingFace Hub
• Zorg dat er voldoende schijfruimte is in ~/.cache/huggingface
• Voor beperkte modellen, stel HF_TOKEN omgevingsvariabele in
• Probeer handmatig te downloaden met huggingface-cli download <model>

Geavanceerde functies

Speculatieve decoding

vLLM ondersteunt speculatieve decoding, waarbij een kleinere draftmodel tokens voorstelt die een groter doelmodel verifieert. Dit kan de 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 dan welke adapter je per aanvraag wilt gebruiken:

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

Multi-LoRA serveren

vLLM’s multi-LoRA serveren stelt het hosten van tientallen fijnafgestelde adapters met minimale geheugenoverhead mogelijk. Dit is ideaal voor het serveren van klantenspecifieke of taakspecifieke modelvarianten:

# Aanvraag 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"}
)

Prefixcaching

Schakel automatisch prefixcaching in om herberekening van KV-cache voor herhalende promptvoorvoegsels te vermijden:

--enable-prefix-caching

Dit is vooral effectief voor:

• Chatbots met vaste systeemmeldingen
• RAG-toepassingen met consistente contextsjablonen
• Few-shot learning prompts herhaald over aanvragen

Prefixcaching kan de tijd tot eerste token verminderen met 50-80% voor aanvragen met gedeelde promptvoorvoegsels.

Integratievoorbeelden

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 eenvoudige 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-toepassing

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}

Prestatiebenchmarks

Reële wereldprestatiegegevens helpen om de voordelen van vLLM te illustreren:

Doorgangvergelijking (Mistral-7B op A100 GPU):

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

Geheugen-efficiëntie (LLaMA-2-13B):

• Standaardimplementatie: 24 GB VRAM, 32 gelijktijdige sequenties
• vLLM met PagedAttention: 24 GB VRAM, 128 gelijktijdige sequenties
• Resultaat: 4x meer gelijktijdige aanvragen met dezelfde geheugen

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

• vLLM: P50 latentie 180 ms, P99 latentie 420 ms bij 100 aanvragen/sec
• Standaard serveren: P50 latentie 650 ms, P99 latentie 3.200 ms bij 100 aanvragen/sec
• Resultaat: vLLM behoudt consistente latentie onder hoge belasting

Deze benchmarks tonen waarom vLLM de standaard geworden is voor productie LLM-serveren waar prestaties belangrijk zijn.

Kostenanalyse

Het begrijpen van de kostenimplicaties van het kiezen van vLLM:

Scenario: 1 miljoen aanvragen per dag

Met standaardserveren:

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

Met vLLM:

• Vereist: 2x A100 GPUs (80 GB)
• AWS-kosten: ~$8/uur × 24 × 30 = $5.760 per maand
• Kosten per 1 miljoen tokens: ~$0,19
• Besparing: $17.280 per maand (75% verminderd)

Deze kostenvoordelen groeien met schaal. Organisaties die miljarden tokens per maand serveren besparen honderdduizenden dollars door vLLM’s geoptimaliseerde serveren in plaats van naïeve implementaties te gebruiken.

Beveiligingsoverwegingen

Authenticatie

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

# 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 ratelimiting.

Netwerkisolatie

Voer vLLM uit 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

Ratelimiting

Implementeer ratelimiting om misbruik te voorkomen:

# Voorbeeld met Redis voor ratelimiting
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 seconde window
    
    if requests > 60:  # 60 aanvragen per minuut
        raise HTTPException(status_code=429, detail="Rate limit overschreden")
    
    return await call_next(request)

Modeltoegangscontrole

Voor meergebruikersimplementaties, controleer welke gebruikers welke modellen kunnen toegang krijgen:

ALLOWED_MODELS = {
    "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_access(user_tier: str, model: str) -> bool:
    allowed = ALLOWED_MODELS.get(user_tier, [])
    return "*" in allowed or model in allowed

Migratiegids

Van OpenAI naar vLLM

Migreren van OpenAI naar zelfgehoste vLLM is eenvoudig dankzij API-compatibiliteit:

Voor (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 je authenticatie toegevoegd hebt
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Hallo"}]
)

Alleen twee wijzigingen nodig: update base_url en model naam. Alle andere code blijft identiek.

Van Ollama naar vLLM

Ollama gebruikt een andere API-indeling. 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?"
)

Je moet de API-aanroepen door je codebase updaten, maar de OpenAI clientbibliotheken bieden betere foutafhandeling en functies.

Van HuggingFace Transformers naar vLLM

Directe Python-gebruiksmigratie:

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 batchinference.

Toekomst van vLLM

vLLM blijft snel ontwikkeld met opwindende functies op de roadmap:

Gescheiden serveren: Het scheiden van prefill (promptverwerking) en decode (tokengeneratie) op verschillende GPUs om bronnenoptimalisatie te verbeteren. Prefill is rekenkrachtgebonden terwijl decode geheugengebonden is, dus het uitvoeren op gespecialiseerde hardware verbetert efficiëntie.

Multi-node inferentie: Het verdelen van zeer grote modellen (100B+ parameters) over meerdere machines, waardoor het serveren van modellen mogelijk wordt die te groot zijn voor enkelnode-setup.

Versterkte quantisatie: Ondersteuning voor nieuwe quantisatieformaten zoals GGUF (gebruikt door llama.cpp) en verbeterde AWQ/GPTQ-integratie voor betere prestaties met gequantiseerde modellen.

Speculatieve decoding verbeteringen: Meer efficiënte draftmodellen en aanpasselijke speculatiestrategieën om hogere snelheidsverhogingen te bereiken zonder nauwkeurigheid te verliezen.

Aandachtsoptimalisaties: FlashAttention 3, ringaandacht voor extreem lange contexten (100K+ tokens) en andere cutting-edge aandachtmechanismen.

Beter modelcoverage: Uitbreiding van ondersteuning naar multimodale modellen (beeld-taalmodellen), audiomodellen en gespecialiseerde architectuur als ze verschijnen.

Het vLLM-project behoudt actieve ontwikkeling met bijdragen van UC Berkeley, Anyscale en de bredere open-source community. Terwijl LLM-implementatie steeds belangrijker wordt voor productiesystemen, groeit vLLM’s rol als prestatiestandaard verder. Voor een bredere vergelijking van vLLM met andere lokale en cloud LLM-infrastructuur, zie onze LLM Hosting: Local, Self-Hosted & Cloud Infrastructure Compared.

Nuttige Links

Gerelateerde artikelen op deze site

• Lokaal LLM-hosting: Compleet 2026 gids - Ollama, vLLM, LocalAI, Jan, LM Studio & Meer - Compleet overzicht van 12+ lokale LLM-hosting-tools, inclusief gedetailleerde analyse van vLLM naast Ollama, LocalAI, Jan, LM Studio en anderen. Bevat informatie over API-rijpheid, ondersteuning voor tool-aanroep, GGUF-compatibiliteit en prestatiebenchmarks om de juiste oplossing te kiezen.

• Ollama Cheat Sheet - Volledige Ollama commandoreferentie en cheat sheet die de installatie, modelbeheer, API-gebruik en best practices voor lokale LLM-implementatie behandelt. Essentieel voor ontwikkelaars die Ollama gebruiken, of in plaats van vLLM.

• Docker Model Runner vs Ollama: Welke kiezen? - Gedetailleerde vergelijking van Docker’s Model Runner en Ollama voor lokale LLM-implementatie, met analyse van prestaties, GPU-ondersteuning, API-compatibiliteit en gebruikscases. Helpt bij het begrijpen van het concurrentie-landschap waarin vLLM actief is.

• Docker Model Runner Cheat Sheet: Commando’s & Voorbeelden - Praktische Docker Model Runner cheat sheet met commando’s en voorbeelden voor AI-modelimplementatie. Nuttig voor teams die Docker’s aanpak vergelijken met de gespecialiseerde LLM-servercapaciteiten van vLLM.

Externe bronnen en documentatie

• vLLM GitHub Repository - Officiële vLLM repository met broncode, uitgebreide documentatie, installatiegidsen en actieve communitydiscussies. Essentiële bron om op de hoogte te blijven van de nieuwste functies en problemen op te lossen.

• vLLM Documentatie - Officiële documentatie die alle aspecten van vLLM behandelt, van basisinstallatie tot geavanceerde configuratie. Bevat API-referenties, gidsen voor prestatieoptimalisatie en best practices voor implementatie.

• PagedAttention Paper - Academisch paper dat de PagedAttention-algoritme introduceert die de efficiëntie van vLLM ondersteunt. Essentieel om de technische innovaties achter de prestatievoordelen van vLLM te begrijpen.

• vLLM Blog - Officiële vLLM blog met release-annonces, prestatiebenchmarks, technische diepgangen en communitycase studies uit productieimplementaties.

• HuggingFace Model Hub - Uitgebreide repository van open-source LLM’s die compatibel zijn met vLLM. Zoek naar modellen op grootte, taak, licentie en prestatiekenmerken om het juiste model voor je gebruikssituatie te vinden.

• Ray Serve Documentatie - Ray Serve framework documentatie voor het bouwen van schaalbare, gedistribueerde vLLM-implementaties. Ray biedt geavanceerde functies zoals automatisch schalen, multi-modellerveren en resourcebeheer voor productiesystemen.

• NVIDIA TensorRT-LLM - NVIDIA’s TensorRT-LLM voor zeer geoptimaliseerde inferentie op NVIDIA GPUs. Alternatief voor vLLM met andere optimalisatiestrategieën, nuttig voor vergelijking en begrip van het inferentieoptimalisatiespectrum.

• OpenAI API Referentie - Officiële OpenAI API documentatie waarmee de API van vLLM compatibel is. Gebruik deze als referentie bij het bouwen van toepassingen die moeten werken met zowel OpenAI als zelfgehoste vLLM-eindpunten.