Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Einsatz mit vLLM

Lektion 11 von 14 Aktualisiert am 29. Juli 2026 Fortgeschritten
Auf dieser Seite
  1. vLLM: Der empfohlene Inferenz-Engine
  2. Was Sie benötigen
  3. Offline-Modus: Verarbeitung von Batches
  4. Server-Modus: Bereitstellung einer API
  5. Docker-Bereitstellung
  6. Die drei wesentlichen Mistral-Flags
  7. Leistungsoptimierung
  8. Kernaussagen

vLLM: Der empfohlene Inferenz-Engine

vLLM ist die beliebteste Python-Inferenz-Engine für LLMs. Mistral AI empfiehlt sie für das Selbsthosting, da sie einfach zu bedienen ist, gute Leistung bietet und eine OpenAI-kompatible API bereitstellt. Wir gehen die Installation und Konfiguration durch und erläutern anschließend ihre beiden Nutzungsmodi: Batch-Modus (offline) und Server-Modus. Diese Modi schließen sich nicht gegenseitig aus – viele Teams nutzen den ersten zum Vorbereiten von Daten und den zweiten zum Bereitstellen von Anwendungen.

Was Sie benötigen

Das Herunterladen von Modellen erfolgt über Hugging Face, was ein Token mit READ-Berechtigung erfordert:

export HF_TOKEN="hf_your_token_here"

Bevor Sie das erste Mal herunterladen, müssen Sie die Nutzungsbedingungen auf der Modell-Seite von Hugging Face akzeptieren (zum Beispiel: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Dies ist ein einmaliger manueller Schritt pro Konto. Das Vergessen dieses Schritts führt zu Download-Fehlern, die bis zu einer Stunde zur Diagnose benötigen können, da sie wie Authentifizierungsprobleme aussehen.

Für die Python-Umgebung verwenden Sie eine dedizierte virtuelle Umgebung, um Versionskonflikte mit Ihren anderen Projekten zu vermeiden:

# Virtuelle Umgebung erstellen
python -m venv vllm-env
source vllm-env/bin/activate

# vLLM installieren (Version >= 0.6.1.post1)
pip install vllm

Dann gibt es die Hardware, die bestimmt, was Sie tatsächlich bereitstellen können. Mistral 7B und Nemo passen auf eine einzelne 24 GB GPU, typischerweise eine A10G, RTX 4090 oder L4. Mixtral 8x7B benötigt zwei 80 GB GPUs, in der Praxis A100-80GB-Karten. Mistral Large 2 in seiner offenen Gewichts-Version mit seinen 123 Milliarden Parametern benötigt mindestens vier A100-80GB GPUs. In allen Fällen installieren Sie NVIDIA-Treiber und CUDA 12.x vor vLLM.

Offline-Modus: Verarbeitung von Batches

Der Offline-Modus verarbeitet Batches von Anfragen ohne einen HTTP-Server. Sie laden das Modell in den Arbeitsspeicher, verarbeiten Ihre Anfragen und holen die Ergebnisse ab. Beachten Sie die drei Argumente tokenizer_mode, load_format und config_format: darauf werden wir noch zurückkommen – sie sind nicht optional.

from vllm import LLM
from vllm.sampling_params import SamplingParams

# Modell mit Mistral-Flags laden
llm = LLM(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    tokenizer_mode="mistral",
    load_format="mistral",
    config_format="mistral"
)

# Generierungsparameter
sampling = SamplingParams(
    max_tokens=8192,
    temperature=0.3
)

# Verarbeitung eines Batches von Anfragen
messages_batch = [
    [{"role": "user", "content": "Was ist PagedAttention?"}],
    [{"role": "user", "content": "Erklären Sie Tensor-Parallelismus."}],
    [{"role": "user", "content": "Wie funktioniert der KV-Cache?"}],
]

results = llm.chat(messages=messages_batch[0], sampling_params=sampling)
for output in results:
    print(output.outputs[0].text)

Dieser Modus eignet sich hervorragend für die Batch-Dokumentverarbeitung – Zusammenfassung, Klassifizierung –, die Modellbewertung gegenüber Benchmarks, die Generierung synthetischer Daten und Test- oder Prototyping-Skripte. Wenn niemand auf eine sofortige Antwort wartet, profitieren Sie davon, die HTTP-Schicht zu überspringen.

Server-Modus: Bereitstellung einer API

Der Server-Modus startet einen HTTP-Endpunkt, der mit der OpenAI-API kompatibel ist:

vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --host 0.0.0.0 \
    --port 8000

Der Server stellt die API auf Port 8000 bereit. Die praktische Konsequenz ist erheblich: Eine Anwendung, die für die OpenAI-API geschrieben wurde, wechselt zu Ihrem selbstgehosteten Modell, indem zwei Zeilen geändert werden: base_url und api_key. Ihre Bibliotheken, Agent-Frameworks und Testwerkzeuge funktionieren weiterhin.

from openai import OpenAI

# Verbindung zum lokalen vLLM-Server herstellen
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # Standardmäßig keine Authentifizierung
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    messages=[
        {"role": "system", "content": "Sie sind ein DevOps-Experte."},
        {"role": "user", "content": "Wie überwache ich einen vLLM-Server in der Produktion?"}
    ],
    temperature=0.3,
    max_tokens=1024
)
print(response.choices[0].message.content)

Der Kommentar # Standardmäßig keine Authentifizierung verdient Aufmerksamkeit: Ein vLLM-Server, der auf diese Weise gestartet wird, authentifiziert niemanden. Auf einer Entwicklungsmaschine ist das bequem. Auf einer maschinell über das Netzwerk zugänglichen Maschine ist es eine offene Tür. Ein schneller Befehlszeilentest bestätigt, dass alles reagiert, bevor man weitermacht:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-Nemo-Instruct-2407",
        "messages": [{"role": "user", "content": "Hallo, funktioniert das?"}],
        "temperature": 0.3
    }'

Docker-Bereitstellung

Für eine reproduzierbare Bereitstellung vermeidet das offizielle Image das Neuinstallieren auf jeder Maschine:

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --load_format mistral \
    --config_format mistral

Drei Optionen in diesem Befehl verdienen eine Erklärung. --runtime nvidia --gpus all gibt dem Container Zugriff auf NVIDIA-GPUs; ohne diesen würde das Modell versuchen, auf der CPU zu laufen. Die Mount-Option -v ~/.cache/huggingface:... teilt den Modell-Cache mit dem Host und spart Ihnen das erneute Herunterladen von Zehnen von Gigabytes, jedes Mal, wenn der Container neu gestartet wird. --ipc=host gewährt den gemeinsamen Speicher, der für die Interprozesskommunikation zwischen GPUs benötigt wird; das Weglassen führt zu schwer zu diagnostizierenden Abstürzen, sobald Sie zu mehreren Karten übergehen.

Die drei wesentlichen Mistral-Flags

FlagZweck
--tokenizer_mode mistralVerwendet den nativen Mistral-Tokenizer (nicht den von HF)
--config_format mistralLädt die Konfiguration im Mistral-Format
--load_format mistralLädt die Gewichte im nativen Mistral-Format

Ohne diese Flags kann das Modell zwar laufen, aber mit verschlechterter Leistung oder falschen Ergebnissen. Dies ist der häufigste Fehler beim Selbsthosting von Mistral: Nichts kracht, der Server startet, die Antworten kommen an – sie sind nur schlechter, als sie sein sollten, und Sie riskieren, fälschlicherweise zu dem Schluss zu kommen, dass das Modell enttäuschend ist.

Leistungsoptimierung

Wenn ein Modell nicht auf einer einzelnen Karte Platz findet, verteilt der Tensor-Parallelismus seine Schichten über mehrere GPUs. Der übergebene Wert entspricht der Anzahl der verwendeten Karten:

vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --tensor-parallel-size 2

Der zweite Hebel betrifft den Anteil des GPU-Speichers, den vLLM reserviert:

vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --gpu-memory-utilization 0.9

Der Standardwert (0,9) funktioniert in den meisten Fällen. Reduzieren Sie ihn, wenn andere Prozesse die GPU nutzen – ein Vision-Dienst, ein vergessener Notebook – andernfalls nimmt der erste Prozess den gesamten Speicher und der zweite Prozess startet nicht.

Schließlich reichen zwei Aufrufe aus, um zu überprüfen, ob ein Server aktiv ist, wodurch sie gute Proben für Ihren Orchestrator sind:

# Verfügbare Modelle auflisten
curl http://localhost:8000/v1/models

# Server-Gesundheit prüfen
curl http://localhost:8000/health

Kernaussagen

  • vLLM stellt eine OpenAI-kompatible API bereit – Sie können die openai-SDK verwenden, um zu kommunizieren
  • Die drei Flags --tokenizer_mode mistral, --config_format mistral, --load_format mistral sind obligatorisch
  • Der Offline-Modus eignet sich für Batch-Verarbeitung; der Server-Modus für Echtzeitanwendungen
  • Docker vereinfacht die Bereitstellung und gewährleistet Reproduzierbarkeit
  • Der Tensor-Parallelismus ermöglicht es Ihnen, große Modelle über mehrere GPUs zu verteilen