vLLM Quickstart: High-Performance LLM Serving

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

Met zijn revolutie-gevende PagedAttention-algoritme, bereikt vLLM een doorvoer van 14-24x hoger dan traditionele dienstverleningsmethoden, waardoor het de voorkeur heeft 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 is geworden voor productieimplementaties. Uitgegeven in 2023, introduceerde het PagedAttention, een doorbraakgevende geheugenbeheermethode die de dienstverlenings-efficiëntie aanzienlijk verbetert.

Belangrijke kenmerken

Hoge doorvoerprestaties: vLLM levert 14-24x hogere doorvoer dan HuggingFace Transformers met dezelfde hardware. Deze enorme prestatieverbetering 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 maakt een vloeiende migratie van OpenAI naar zelfgehoste infrastructuur mogelijk zonder aanpassingen aan de toepassingscode. Simpelweg wijzig je de API-client naar het eindpunt van vLLM en het werkt transparant.

PagedAttention-algoritme: Het kerninnovatie van de prestaties van vLLM is PagedAttention, dat het concept van virtuele geheugenpaging 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 geheugenspilling met tot 4x en maakt veel grotere batchgroottes mogelijk.

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

Ondersteuning voor meerdere GPUs: vLLM ondersteunt tensorparallelisme en pipelineparallelisme voor het verdelen van grote modellen over meerdere GPUs. Het kan efficiënt modellen dienen 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-aangestuurde als basismodellen van HuggingFace Hub.

Wanneer vLLM te gebruiken

vLLM is uitstekend in bepaalde scenario’s waarin zijn sterktes schijnen:

Productie API-diensten: Wanneer je een LLM moet dienen aan veel gelijktijdige gebruikers via API, is vLLM vanwege zijn hoge doorvoer en efficiënte batchverwerking de beste keuze. Bedrijven die chatbots, code-assistenten of inhoudsgeneratie-diensten uitvoeren, 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 met dezelfde hardware te dienen dan alternatieven.

Kostenefficiëntie: Wanneer GPU-kosten een zorg zijn, betekent vLLM’s superieure doorvoer dat je dezelfde verkeer kunt dienen met minder GPUs, wat direct de infrastructuurkosten 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 consistente prestaties 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 eenvoudigere installatie. De complexiteit van vLLM 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 eisen 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 nieuer

Installatie via pip

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

# Maak een virtuele 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 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:

# Haal het officiële vLLM-afbeelding 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

Het vlag --ipc=host is belangrijk voor meervoudige GPU-instellingen, omdat het juiste interprocessencommunicatie mogelijk maakt.

Bouwen vanuit bron

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

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

Quickstartgids voor vLLM

Uw 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 ingecached) 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 maken 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 de 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 over voor geheugenpieken.
• --max-model-len: Maximaal contextlengte. Verminderen van deze waarde spaart geheugen voor grotere batches.
• --tensor-parallel-size: Aantal GPUs waarover het model moet worden verdeeld.
• --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 gebruiksscenario’s. Het begrijpen van wanneer elk gereedschap te gebruiken is kan aanzienlijk invloed hebben op het succes van je project.

Prestaties en doorvoer

vLLM is ontworpen voor maximale doorvoer 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 doorvoer bereikt dan standaardimplementaties en 2-4x hoger dan Ollama onder hoge concurrentie.

Ollama optimaliseert voor single-user interactieve gebruik met focus op lage latentie voor individuele aanvragen. Hoewel het de doorvoer van vLLM niet overtreft in meergebruikersscenario’s, biedt het uitstekende prestaties voor ontwikkeling en persoonlijk gebruik met snellere opstarttijden en lager verbruik van ongebruikte resources.

Eenvoud van gebruik

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

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

API en integratie

vLLM biedt standaard OpenAI-compatibele REST-Api’s, waardoor het een drop-in vervanging is voor de OpenAI-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 specifieke Python/JavaScript-bibliotheek. Hoewel functioneel, is het niet OpenAI-compatibel, wat codeveranderingen vereist 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 vergeleken met naïeve implementaties. Dit vertaalt direct in kostensparing in productieimplementaties.

Ollama gebruikt eenvoudiger geheugenbeheer dat geschikt is 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 is voor hoge-concurrentie productiegebruik.

Ondersteuning voor meerdere GPUs

vLLM excelleert met native tensorparallelisme en pipelineparallelisme, efficiënt verdeeld 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 ondersteuning voor meerdere GPUs, werkt 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 met veel gelijktijdige gebruikers
• Je kost per aanvraag in cloudimplementaties optimaliseert
• Je in Kubernetes of containerorchestratieplatforms werkt
• Je OpenAI API-compatibiliteit nodig hebt voor bestaande toepassingen
• Je grote modellen moet dienen die meerdere GPU-ondersteuning vereisen
• Prestaties en doorvoer kritieke eisen zijn

Kies Ollama wanneer:

• Lokale ontwikkeling en experimenten
• Single-user interactief gebruik (persoonlijke assistenten, chatbots)
• Snel prototyperen en modelbeoordelen
• Leren over LLMs zonder infrastructuurcomplexiteit
• Je op persoonlijke werkstations of laptops werkt
• Eenvoud en gebruiksgemak prioriteiten zijn

Veel teams gebruiken beide: Ollama voor ontwikkeling en experimenten, en vLLM voor productieimplementatie. Dit combineren 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 strebt erna om de “Docker voor AI” te zijn – een eenvoudige, gestandaardiseerde manier om AI-modellen lokaal uit te voeren met dezelfde gemak als het uitvoeren van containers. Het abstracte complexiteit en biedt een consistente interface over verschillende modellen en frameworks.

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

Setup en aan de slag gaan

Docker Model Runner installatie is eenvoudig voor Docker-gebruikers:

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

Deze gelijkenis met de Docker-afbeeldingswerkwijze maakt het direct bekend voor ontwikkelaars die al containers gebruiken.

vLLM vereist meer initiële setup (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 doorvoer voor meergebruikersscenario’s dankzij PagedAttention en continue batchverwerking. Voor productie-API-diensten die honderden aanvragen per seconde moeten verwerken, bieden de optimalisaties van vLLM 2-5x betere doorvoer dan generieke dienstverleningsbenaderingen.

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-opdracht 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 transformergebaseerde taalmodellen. Het ondersteunt elk HuggingFace-compatibel 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 anderen 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 het Docker-ecosysteem en Docker Desktop. Voor teams die al gestandaardiseerd zijn op Docker, biedt deze integratie een samenhangend ervaring, maar minder gespecialiseerde LLM-dienstverleningskenmerken.

Wanneer elk te gebruiken

Gebruik vLLM voor:

• Productie LLM API-diensten
• Hoge-doorvoer, meergebruikersimplementaties
• Kostenbewuste 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 uitvoeren van verschillende AI-modeltypes (niet alleen LLMs)
• Teams die zwaar zijn gestandaardiseerd op het Docker-ecosysteem
• Snel experimenteren zonder infrastructuursetup
• Leerdoeleinden

Hybride aanpak: Veel teams ontwikkelen met Docker Model Runner lokaal voor gemak, en 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 productie-gekwalificeerde 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 dit aan op basis van waargenomen gedrag. Hogere waarden laten grotere batches toe, maar verhogen het risico op OOM-fouten tijdens pieken in verkeer.

Stel maximaal sequentielengte in: Als je gebruikscase geen volledige contextlengte vereist, 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 (vaak 8K-32K).

Kies geschikte kwantisatie: Voor modellen die dit ondersteunen, gebruik dan gekwantiseerde versies (8-bit, 4-bit) om geheugen te verminderen en doorvoer te verhogen:

--quantization awq  # Voor AWQ-gekwantiseerde modellen
--quantization gptq # Voor GPTQ-gekwantiseerde 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 van veelvoorkomende problemen

Geheugenproblemen

Symptomen: Server stort met CUDA-geheugenfouten.

Oplossingen:

• Verminder --gpu-memory-utilization naar 0,85 of 0,80
• Verminder --max-model-len als je gebruikscase dat toelaat
• Verminder --max-num-seqs om batchgrootte te verkleinen
• Gebruik een gekwantiseerde modelversie
• Schakel tensorparallelisme in om over meer GPUs te verspreiden

Lage doorvoer

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

Oplossingen:

• Gebruik kleinere modellen voor toepassingen waar latentie kritiek is
• Schakel prefixcaching in voor herhalende prompts
• Verminder --max-num-seqs om latentie voor doorvoer te prioriteren
• 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 netwerkconnectiviteit naar 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 schetsmodel 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

Vervolgens specificeer welke adapter je per aanvraag gebruikt:

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 dienstverlening

vLLM’s multi-LoRA dienstverlening maakt het mogelijk om tientallen gefine-tuned adapters te hosten met minimale geheugenoverhead. Dit is ideaal voor het dienen 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 te vermijden voor herhalende promptvoorvoegsels:

--enable-prefix-caching

Dit is vooral effectief voor:

• Chatbots met vaste systeemberichten
• RAG-toepassingen met consistente contextsjablonen
• Weinigvoorbeeldlerende prompts die over meerdere aanvragen worden herhaald

Prefixcaching kan tijd tot eerste token verminderen met 50-80% voor aanvragen met gemeenschappelijke 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

Rale-world prestatiedata helpt om de voordelen van vLLM te illustreren:

Doorschakelvergelijking (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 over basisimplementaties

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

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

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

• vLLM: P50 latentie 180ms, P99 latentie 420ms bij 100 req/s
• Standaard dienstverlening: P50 latentie 650ms, P99 latentie 3.200ms bij 100 req/s
• Resultaat: vLLM behoudt consistente latentie onder hoge belasting

Deze benchmarks tonen waarom vLLM de standaard is geworden 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 (80GB)
• AWS-kosten: ~$32/uur × 24 × 30 = $23.040/maand
• Kosten per 1 miljoen tokens: ~$0,75

Met vLLM:

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

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

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 meertenantimplementaties, controleer 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 de API-aanvragen 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:

Geïsoleerde dienstverlening: 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 dienen van modellen mogelijk wordt die te groot zijn voor enkelnode-setup.

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

Speculatieve decodingverbeteringen: Meer efficiënte schetsmodellen en aanpasselijke speculatiestrategieën om hogere snelheidsverhogingen te bereiken zonder nauwkeurigheidsverlies.

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

Beter modelondersteuning: Uitbreiding van de ondersteuning naar multimodale modellen (visuele taalmodellen), audiomodellen en gespecialiseerde architecturen naarmate ze verschijnen.

Het vLLM-project onderhoudt actieve ontwikkeling met bijdragen van UC Berkeley, Anyscale en de brede open-source gemeenschap. Aangezien LLM-implementatie steeds belangrijker wordt voor productiesystemen, groeit de rol van vLLM als prestatiestandaard voortdurend.

Nuttige links

Gerelateerde artikelen op deze site

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

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

• Docker Model Runner vs Ollama: Welk product 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 concurrentie-landschap waarin vLLM operatieert 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 Docker’s aanpak vergelijken met vLLM’s gespecialiseerde LLM-servercapaciteiten.

Externe bronnen en documentatie

• vLLM GitHub-repository - Officiële vLLM-repository met broncode, uitgebreide documentatie, installatiegidsen en actieve communitydiscussies. Essentieel 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 basisopstelling 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-annoncés, prestatiebenchmarks, technische diepgangen en communitycase studies van productiedeployments.

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

• Ray Serve Documentatie - Ray Serve frameworkdocumentatie voor het bouwen van schaalbare, gedistribueerde vLLM-implementaties. Ray biedt geavanceerde functies zoals automatisch schalen, multi-modelserven 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 inferentieoptimalisatielandschap.

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