vLLM Quickstart: High-Performance LLM Serving - in 2026

vLLM is een hoogdoorlopende, geheugen-efficiënte engine voor inferentie en diensten van grote taalmodellen (LLMs) ontwikkeld door het Sky Computing Lab van UC Berkeley.

Met zijn revolutie-gebrengde PagedAttention-algoritme, bereikt vLLM een doorlopende capaciteit die 14-24x hoger is dan traditionele dienstverleningsmethoden, waardoor het de voorkeur krijgt voor productieimplementaties van LLMs.

Wat is vLLM?

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

Belangrijke kenmerken

Hoge doorlopende prestaties: vLLM levert een doorlopende capaciteit die 14-24x hoger is dan HuggingFace Transformers met hetzelfde hardware. Deze enorme prestatiegroei komt voort uit continue batchverwerking, geoptimaliseerde CUDA-kernels en het PagedAttention-algoritme dat geheugenfragmentatie elimineert.

Compatibiliteit met OpenAI API: vLLM bevat een ingebouwde API-server die volledig compatibel is met het formaat van OpenAI. Dit stelt een naadloze migratie van OpenAI naar zelfgehoste infrastructuur mogelijk zonder de toepassingscode te wijzigen. Geef eenvoudigweg je API-client aan vLLM’s eindpunt en het werkt transparant.

PagedAttention-algoritme: Het kerninnovatie van de prestaties van vLLM is PagedAttention, die het concept van virtuele geheugenpagina’s toepast op aandachtmechanismen. In plaats van continue geheugenblokken te alloqueren voor KV-caches (wat leidt tot fragmentatie), verdeelt PagedAttention geheugen in vaste grootteblokken die op aanvraag kunnen worden toegewezen. Dit verminderd geheugenverspilling met tot 4x en maakt veel grotere batchgroottes mogelijk.

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

Meervoudige GPU-ondersteuning: vLLM ondersteunt tensorparallelisme en pipelineparallelisme voor het verdelen van grote modellen over meerdere GPUs. Het kan efficiënt diensten leveren aan modellen 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-afgestemde als basismodellen van HuggingFace Hub.

Wanneer vLLM te gebruiken

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

Productie API-diensten: Wanneer je een LLM moet dienen aan veel gelijktijdige gebruikers via API, is vLLM’s hoge doorlopende capaciteit 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 toepassing veel gelijktijdige gebruikers heeft die aanvragen doen, maakt vLLM’s continue batchverwerking en PagedAttention het mogelijk om meer gebruikers te dienen met dezelfde hardware in vergelijking met alternatieven.

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

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

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

Hoe vLLM te 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 virtuele omgeving aan (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 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 implementatiemethode, vooral voor productie:

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

# Voer vLLM uit 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 meervoudige GPU-instellingen omdat het juiste interprocessencommunicatie 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 .

vLLM Quickstart Guide

Je eerste model uitvoeren

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 met behulp van 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

# Richt je naar 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 verklaard:

• --gpu-memory-utilization: Hoeveel GPU-geheugen te gebruiken (0.90 = 90%). Hogere waarden toestaan grotere batches, maar laten minder ruimte over voor geheugenpieken.
• --max-model-len: Maximaal contextlengte. Verminderen van deze waarde bespaart geheugen voor grotere batches.
• --tensor-parallel-size: Aantal GPUs waarop het model moet worden gesplitst.
• --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 toepassingsgebieden. Het begrijpen van wanneer je elk hulpmiddel moet gebruiken kan aanzienlijk invloed hebben op het succes van je project.

Prestaties en doorlopende capaciteit

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

Ollama optimaliseert voor single-gebruikersinteractieve gebruik met focus op lage latentie voor individuele aanvragen. Hoewel het niet overtreft vLLM’s meergebruikersdoorlopende capaciteit, biedt het uitstekende prestaties voor ontwikkeling en persoonlijk gebruik met snellere starttijden en lagere inactieve resourceverbruik.

Gebruiksgemak

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

vLLM vereist meer opzet: Python-omgevingsbeheer, CUDA-installatie, begrip van dienstverleningsparameters 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 halen 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, waardoor codeveranderingen vereist zijn bij integratie met toepassingen die het OpenAI-formaat 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-4x meer gelijktijdige gebruikers dienen met hetzelfde VRAM in vergelijking met naïeve implementaties. Dit vertaalt direct in kostenbesparingen in productieimplementaties.

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

Meervoudige GPU-ondersteuning

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

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

Gebruikscasus aanbevelingen

Kies vLLM wanneer:

• Je productie-API’s moet dienen met veel gelijktijdige gebruikers
• Je kost per aanvraag in cloudimplementaties optimaliseert
• Je in Kubernetes of containerorchestratieplatforms draait
• Je OpenAI API-compatibiliteit nodig hebt voor bestaande toepassingen
• Je grote modellen moet dienen die meervoudige GPU-ondersteuning vereisen
• Prestaties en doorlopende capaciteit kritieke vereisten zijn

Kies Ollama wanneer:

• Lokale ontwikkeling en experimenten
• Single-gebruikersinteractieve gebruik (persoonlijke assistenten, chatbots)
• Snel prototyperen en modelbeoordeling
• Leren over LLMs zonder infrastructuurcomplexiteit
• Op persoonlijke werkstations of laptops draaien
• Eenvoud en gebruiksgemak prioriteiten zijn

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

vLLM vs Docker Model Runner

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

Architectuurfilosofie

Docker Model Runner richt zich op het zijn van het “Docker voor AI” – een eenvoudige, gestandaardiseerde manier om AI-modellen lokaal uit te voeren met dezelfde gemak als containers uitvoeren. Het abstracte complexiteit en biedt een consistente interface over verschillende modellen en frameworks.

vLLM is een gespecialiseerde inferentie-engine die zich volledig op LLM-dienstverlening richt met maximale prestaties. Het is een lagere laag tool die je containerise met Docker, in plaats van een volledig platform.

Opzet 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 beeldwerkstroom maakt het direct bekend voor ontwikkelaars die al containers gebruiken.

vLLM vereist meer initiële opzet (Python, CUDA, afhankelijkheden) of het gebruik van vooraf gebouwde Docker-afbeeldingen:

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

Prestatiekenmerken

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

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) zoals 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 transformer-gebaseerde taalmodellen. Het ondersteunt elke HuggingFace-compatibele LLM, maar reikt niet uit naar 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 dienen. Zijn prestatiekenmerken en stabiliteit onder zware belasting maken het de standaard voor productie-LLM-dienstverlening.

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

Integratieecosysteem

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

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

Wanneer elk te gebruiken

Gebruik vLLM voor:

• Productie LLM API-diensten
• Hoge-doorlopende, meergebruikersimplementaties
• Kostenbewuste cloudimplementaties die maximale efficiëntie nodig hebben
• 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 sterk in Docker-ecossysteem zijn
• Snel experimenteren zonder infrastructuuropzet
• 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-afbeeldingen kunnen ook worden gebruikt om vLLM-containers uit te voeren, wat beide aanpakken combineert.

Best Practices voor productieimplementatie

Docker-implementatie

Maak een productiebereide 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-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

# Get metrics
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 toestaan grotere batches, maar riskeer OOM-fouten tijdens verkeerspieken.

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

Kies passende kwantisatie: Voor modellen die dat ondersteunen, gebruik kwantiseerde versies (8-bit, 4-bit) om geheugen te verminderen en doorlopende capaciteit te verhogen:

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

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

--enable-prefix-caching

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

Probleemoplossing voor veelvoorkomende problemen

Geheugenuitputting

Symptomen: Server crash met CUDA-geheugenuitputting fouten.

Oplossingen:

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

Lage doorlopende capaciteit

Symptomen: Server verwerkt minder aanvragen dan verwacht.

Oplossingen:

• Vermeerder --max-num-seqs om grotere batches toestaan
• 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: Hoog latentie voor het starten van generatie.

Oplossingen:

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

Modelbelastingfouten

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

Oplossingen:

• Controleer of modelnaam exact overeenkomt met HuggingFace-formaat
• 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 voorlopig model tokens voorstelt die een grotere doelmodel 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

Dan specificeer 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 aangemaakt deze maand"
)

Multi-LoRA dienstverlening

vLLM’s multi-LoRA dienstverlening stelt het hosten van tientallen fijnafgestemde adapters met minimale geheugenoverhead mogelijk. Dit is ideaal voor het dienen van klantspecifieke 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 een 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 systeemprompts
• RAG-toepassingen met consistente contextsjablonen
• Weinig-voorbeeldenlerende prompts herhaald over aanvragen

Prefixcaching kan 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 in eenvoudige termen uit")
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 wereldprestatiedata helpt om de voordelen van vLLM te illustreren:

Doorlopende vergelijking (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 req/s
• Standaard dienstverlening: P50 latentie 650 ms, P99 latentie 3.200 ms bij 100 req/s
• Resultaat: vLLM behoudt consistente latentie onder hoge belasting

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

Kostenanalyse

Het begrijpen van de kostenimplicaties van het kiezen van vLLM:

Scenario: 1 miljoen aanvragen per dag dienen

Met standaard dienstverlening:

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

Met vLLM:

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

Deze kostenvoordelen groeien met schaal. Organisaties die miljarden tokens per maand dienen, besparen honderdduizenden dollars per maand door vLLM’s geoptimaliseerde dienstverlening in plaats van basisimplementaties 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-gegradeerde authenticatie en rate limiting.

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

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

Modeltoegangscontrole

Voor meervoudige tenantimplementaties, beheer welke gebruikers welke modellen kunnen gebruiken:

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 veranderingen nodig: update base_url en model naam. Al het 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?"
)

Je moet API-aanroepen overal in je codebasis bijwerken, 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:

Gesplitste dienstverlening: Het scheiden van prefill (promptverwerking) en decode (tokengeneratie) op verschillende GPUs om bronnen te optimaliseren. Prefill is rekenkrachtsgesneden terwijl decode geheugengesneden is, dus het uitvoeren op gespecialiseerde hardware verbetert efficiëntie.

Meervoudige knooppuntinference: Het verdelen van zeer grote modellen (100B+ parameters) over meerdere machines, waardoor het dienen van modellen mogelijk wordt die te groot zijn voor enkelvoudige knooppuntsetups.

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

Speculatieve decodingverbeteringen: Meer efficiënte voorlopige modellen en aanpassende 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 modeldeksel: Uitbreiding van ondersteuning naar multimodale modellen (visuele taalmodellen), audiomodellen en gespecialiseerde architectuur als ze verschijnen.

Het vLLM-project behoudt actieve ontwikkeling met bijdragen van UC Berkeley, Anyscale en de breder open-source gemeenschap. Terwijl LLM-implementatie steeds belangrijker wordt voor productiesystemen, groeit vLLM’s rol als prestatiestandaard steeds meer.

Handige links

Gerelateerde artikelen op deze site

• Lokaal LLM-hosting: Volledige gids 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Meer - Volledige vergelijking van 12+ lokale LLM-hosting-tools, waaronder gedetailleerde analyse van vLLM, samen met 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, samen met of in plaats van vLLM.

• Docker Model Runner vs Ollama: Wat kiezen? - Gedetailleerde vergelijking van Docker’s Model Runner en Ollama voor lokale LLM-implementatie, met analyse van prestaties, GPU-ondersteuning, API-compatibiliteit en gebruiksscenario’s. Helpt om het concurrentiepark van vLLM te begrijpen.

• 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 de aanpak van Docker vergelijken met de gespecialiseerde LLM-servingsfunctionaliteiten 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, prestatieoptimalisatiegidsen en implementatiebest practices.

• 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-announcements, prestatiebenchmarks, technische diepgangen en communitycase studies van productiedeployments.

• HuggingFace Model Hub - Uitgebreide repository van open source LLM’s die compatibel zijn met vLLM. Zoek 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-model serving en resourcebeheer voor productiesystemen.

• NVIDIA TensorRT-LLM - NVIDIA’s TensorRT-LLM voor zeer geoptimaliseerde inferentie op NVIDIA GPUs. Alternatief voor vLLM met verschillende optimalisatiestrategieën, nuttig voor vergelijking en begrip van de inferentieoptimalisatie-landschap.

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