vLLM

LLM-Inferenz mit hohem Durchsatz mit vLLM auf Clore.ai-GPUs

Hochdurchsatz-LLM-Inferenzserver für Produktions-Workloads auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Aktuelle Version: v0.7.x — Dieser Leitfaden behandelt vLLM v0.7.3+. Zu den neuen Funktionen gehören DeepSeek-R1-Unterstützung, strukturierte Ausgaben mit automatischer Tool-Auswahl, Multi-LoRA-Bereitstellung und verbesserte Speichereffizienz.

Serveranforderungen

Parameter	Mindest	Empfohlen
RAM	16 GB	32 GB+
VRAM	16 GB (7B)	24 GB+
Netzwerk	500 Mbit/s	1 Gbit/s+
Startzeit	5–15 Minuten	-

Sie brauchen eine passende GPU? Eine RTX 4090 (24 GB) kommt problemlos mit 7B–13B zurecht; für 70B+-Modelle ist eine H100 (80 GB) die sicherste Wahl.

Wichtig: vLLM benötigt erheblichen RAM und VRAM. Server mit weniger als 16 GB RAM können selbst 7B-Modelle nicht ausführen.

Startzeit: Beim ersten Start wird das Modell von HuggingFace heruntergeladen (5–15 Minuten je nach Modellgröße und Netzwerkgeschwindigkeit). HTTP 502 in dieser Zeit ist normal.

Warum vLLM?

• Höchster Durchsatz - PagedAttention für 24x höheren Durchsatz

• Produktionsreif - OpenAI-kompatible API direkt einsatzbereit

• Kontinuierliches Batching - Effiziente Bereitstellung für mehrere Nutzer

• Streaming - Token-Generierung in Echtzeit

• Multi-GPU - Tensor-Parallelismus für große Modelle

• Multi-LoRA - Mehrere feinabgestimmte Adapter gleichzeitig bereitstellen (v0.7+)

• Strukturierte Ausgaben - JSON-Schema-Durchsetzung und Tool-Aufrufe (v0.7+)

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

vllm/vllm-openai:v0.7.3

Ports:

22/tcp
8000/http

Befehl:

vllm serve mistralai/Mistral-7B-Instruct-v0.2 --host 0.0.0.0 --port 8000

Überprüfen, ob es funktioniert

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

# Status prüfen (beim ersten Lauf kann es 5–15 Min. dauern)
curl https://your-http-pub.clorecloud.net/health

# Modelle auflisten (funktioniert erst, nachdem das Modell geladen wurde)
curl https://your-http-pub.clorecloud.net/v1/models

Wenn Sie länger als 15 Minuten HTTP 502 erhalten, prüfen Sie:

1. Der Server hat 16 GB+ RAM

2. Der Server hat genügend VRAM für das Modell

3. HuggingFace-Token ist für geschützte Modelle gesetzt

Auf Ihren Dienst zugreifen

Wenn auf CLORE.AI bereitgestellt, greifen Sie über die http_pub URL zu:

# Chat-Vervollständigung
curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Alle localhost:8000 Beispiele unten funktionieren bei Verbindung über SSH. Für externen Zugriff ersetzen Sie dies durch Ihre https://your-http-pub.clorecloud.net/ URL.

Installation

Mit Docker (empfohlen)

docker run -d --gpus all \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:v0.7.3 \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0

Mit pip

pip install vllm==0.7.3

# Server starten
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2

Unterstützte Modelle

Modell	Parameter	Erforderlicher VRAM	Erforderlicher RAM
Mistral 7B	7B	14 GB	16 GB+
Llama 3.1 8B	8B	16 GB	16 GB+
Llama 3.1 70B	70B	140 GB (oder 2x80 GB)	64 GB+
Mixtral 8x7B	47B	90 GB	32 GB+
Qwen2.5 7B	7B	14 GB	16 GB+
Qwen2.5 72B	72B	145 GB	64 GB+
DeepSeek-V3	236B MoE	Multi-GPU	128 GB+
DeepSeek-R1-Distill-Qwen-7B	7B	14 GB	16 GB+
DeepSeek-R1-Distill-Qwen-32B	32B	64 GB	32 GB+
DeepSeek-R1-Distill-Llama-70B	70B	140 GB	64 GB+
Phi-4	14B	28 GB	32 GB+
Gemma 2 9B	9B	18 GB	16 GB+
CodeLlama 34B	34B	68 GB	32 GB+

Serveroptionen

Basisserver

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000

Produktionsserver

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 1 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --max-num-seqs 256 \
    --enable-prefix-caching

Mit Quantisierung (weniger VRAM)

# AWQ-quantisiertes Modell (verwendet weniger VRAM)
vllm serve TheBloke/Mistral-7B-Instruct-v0.2-AWQ \
    --host 0.0.0.0 \
    --quantization awq

Strukturierte Ausgaben und Tool-Aufrufe (v0.7+)

Aktivieren Sie die automatische Tool-Auswahl und strukturierte JSON-Ausgaben:

vllm serve mistralai/Mistral-7B-Instruct-v0.2 \
    --host 0.0.0.0 \
    --enable-auto-tool-choice \
    --tool-call-parser mistral

Verwendung in Python:

from openai import OpenAI
import json

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Aktuelles Wetter für eine Stadt abrufen",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Stadtname"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Wie ist das Wetter in Paris?"}],
    tools=tools,
    tool_choice="auto"
)

# Tool-Aufruf parsen
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print(f"Tool: {tool_call.function.name}, Args: {args}")

Strukturierte JSON-Ausgabe über das response_format:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Extrahiere: John Smith, 30 Jahre alt, Softwareentwickler"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "occupation": {"type": "string"}
                },
                "required": ["name", "age", "occupation"]
            }
        }
    }
)
print(response.choices[0].message.content)

Multi-LoRA-Bereitstellung (v0.7+)

Stellen Sie ein Basismodell gleichzeitig mit mehreren LoRA-Adaptern bereit:

vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --enable-lora \
    --lora-modules \
        sql-adapter=path/to/sql-lora \
        code-adapter=path/to/code-lora \
        chat-adapter=path/to/chat-lora \
    --max-lora-rank 64

Stellen Sie einen bestimmten LoRA-Adapter über den Modellnamen ab:

# SQL-Adapter verwenden
response = client.chat.completions.create(
    model="sql-adapter",
    messages=[{"role": "user", "content": "Schreibe eine SQL-Abfrage, um die Top-10-Kunden zu finden"}]
)

# Code-Adapter verwenden
response = client.chat.completions.create(
    model="code-adapter",
    messages=[{"role": "user", "content": "Schreibe eine Python-Funktion zum Sortieren einer Liste"}]
)

DeepSeek-R1-Unterstützung (v0.7+)

vLLM v0.7+ bietet native Unterstützung für DeepSeek-R1-Distill-Modelle. Diese Reasoning-Modelle erzeugen <think> Tags, die ihren Denkprozess zeigen.

DeepSeek-R1-Distill-Qwen-7B (Einzel-GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384

DeepSeek-R1-Distill-Qwen-32B (Dual-GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90

DeepSeek-R1-Distill-Llama-70B (Quad-GPU)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768

DeepSeek-R1 abfragen

from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[
        {
            "role": "user",
            "content": "Löse: Wenn ein Zug 120 km in 1,5 Stunden zurücklegt, wie hoch ist seine Geschwindigkeit in m/s?"
        }
    ],
    max_tokens=2048,
    temperature=0.6
)

content = response.choices[0].message.content
# Antwort enthält einen <think>...</think>-Block mit Begründung, gefolgt von der Antwort
print(content)

<think>-Tags parsen:

import re

def parse_deepseek_r1_response(content: str) -> dict:
    """Begründung und Antwort aus der DeepSeek-R1-Antwort extrahieren."""
    think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
    return {"thinking": thinking, "answer": answer}

result = parse_deepseek_r1_response(content)
print("Denken:", result["thinking"][:200], "...")
print("Antwort:", result["answer"])

API-Nutzung

Chat Completions (OpenAI-kompatibel)

from openai import OpenAI

# Für externen Zugriff verwenden Sie Ihre http_pub-URL:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="not-needed"
)

# Oder über SSH-Tunnel:
# client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "user", "content": "Erkläre Quantencomputing"}
    ],
    max_tokens=500,
    temperature=0.7
)

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

Streaming

stream = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Schreibe ein Gedicht"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

cURL

curl https://your-http-pub.clorecloud.net/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 100
  }'

Text-Vervollständigungen

curl https://your-http-pub.clorecloud.net/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Die Hauptstadt von Frankreich ist",
    "max_tokens": 50
  }'

Vollständige API-Referenz

vLLM bietet OpenAI-kompatible Endpunkte sowie zusätzliche Hilfsendpunkte.

Standardendpunkte

Endpunkt	Methode	Beschreibung
/v1/models	GET	Verfügbare Modelle auflisten
/v1/chat/completions	POST	Chat-Vervollständigung
/v1/completions	POST	Text-Vervollständigung
/health	GET	Statusprüfung (kann leer zurückgeben)

Zusätzliche Endpunkte

Endpunkt	Methode	Beschreibung
/tokenize	POST	Text tokenisieren
/detokenize	POST	Tokens in Text umwandeln
/version	GET	vLLM-Version abrufen
/docs	GET	Swagger-UI-Dokumentation
/metrics	GET	Prometheus-Metriken

Text tokenisieren

Nützlich, um Tokens vor dem Senden von Anfragen zu zählen:

curl https://your-http-pub.clorecloud.net/tokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "prompt": "Hello world"
  }'

Antwort:

{"count": 2, "max_model_len": 32768, "tokens": [9707, 1879]}

Detokenisieren

Token-IDs wieder in Text umwandeln:

curl https://your-http-pub.clorecloud.net/detokenize \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.2",
    "tokens": [9707, 1879]
  }'

Antwort:

{"prompt": "Hello world"}

Version abrufen

curl https://your-http-pub.clorecloud.net/version

Antwort:

{"version": "0.7.3"}

Swagger-Dokumentation

Im Browser öffnen für interaktive API-Dokumentation:

https://your-http-pub.clorecloud.net/docs

Prometheus-Metriken

Für Monitoring:

curl https://your-http-pub.clorecloud.net/metrics

Reasoning-Modelle: DeepSeek-R1 und ähnliche Modelle enthalten <think> Tags in Antworten, die den Denkprozess des Modells vor der endgültigen Antwort anzeigen.

Benchmarks

Durchsatz (Tokens/Sek. pro Benutzer)

Modell	RTX 3090	RTX 4090	A100 40 GB	A100 80 GB
Mistral 7B	100	170	210	230
Llama 3.1 8B	95	150	200	220
Llama 3.1 8B (AWQ)	130	190	260	280
Mixtral 8x7B	-	45	70	85
Llama 3.1 70B	-	-	25 (2x)	45 (2x)
DeepSeek-R1 7B	90	145	190	210
DeepSeek-R1 32B	-	-	40	70 (2x)

Benchmarks aktualisiert im Januar 2026.

Kontextlänge vs. VRAM

Modell	4K Kontext	8K Kontext	16K Kontext	32K Kontext
8B FP16	18 GB	22 GB	30 GB	46 GB
8B AWQ	8 GB	10 GB	14 GB	22 GB
70B FP16	145 GB	160 GB	190 GB	250 GB
70B AWQ	42 GB	50 GB	66 GB	98 GB

Hugging-Face-Authentifizierung

Für geschützte Modelle (Llama usw.):

# Token im Befehl setzen
vllm serve meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --env HUGGING_FACE_HUB_TOKEN=hf_xxxxx

Oder als Umgebungsvariable setzen:

export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

GPU-Anforderungen

Modell	Min. VRAM	Min. RAM	Empfohlen
7–8B	16 GB	16 GB	24 GB VRAM, 32 GB RAM
13B	26 GB	32 GB	40 GB VRAM
34B	70GB	32 GB	80 GB VRAM
70B	140 GB	64 GB	2x80 GB

Kostenschätzung

Typische Tarife im CLORE.AI Marketplace:

GPU	VRAM	Preis/Tag	Am besten für
RTX 3090	24 GB	0,30–1,00 $	7–8B-Modelle
RTX 4090	24 GB	0,50–2,00 $	7–13B, schnell
A100	40 GB	1,50–3,00 $	13–34B-Modelle
A100	80 GB	2,00–4,00 $	34–70B-Modelle

Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen Sie CLORE.AI Marketplace die aktuellen Tarife.

Fehlerbehebung

Längere Zeit HTTP 502

1. RAM prüfen: Der Server muss 16 GB+ RAM haben

2. VRAM prüfen: Das Modell muss hineinpassen

3. Modell wird heruntergeladen: Der erste Lauf lädt von HuggingFace herunter (5–15 Min.)

4. HF-Token: Geschützte Modelle erfordern Authentifizierung

Speicher voll

# Speichernutzung reduzieren
--gpu-memory-utilization 0.8
--max-model-len 4096
--max-num-seqs 64

# Oder Quantisierung verwenden
--quantization awq

Modell-Download schlägt fehl

# HF-Token prüfen
echo $HUGGING_FACE_HUB_TOKEN

# Modell vorab herunterladen
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.2

vLLM vs. andere

Funktion	vLLM	llama.cpp	Ollama
Durchsatz	Am besten	Gut	Gut
VRAM-Nutzung	Hoch	Niedrig	Mittel
Benutzerfreundlichkeit	Mittel	Mittel	Einfach
Startzeit	5–15 Min.	1–2 Min.	30 Sek.
Multi-GPU	Nativ	Eingeschränkt	Eingeschränkt
Tool-Aufruf	Ja (v0.7+)	Eingeschränkt	Eingeschränkt
Multi-LoRA	Ja (v0.7+)	Nein	Nein

Verwende vLLM, wenn:

• Hoher Durchsatz hat Priorität

• Mehrere Benutzer bedienen

• Genügend VRAM und RAM vorhanden sind

• Produktionsbereitstellung

• Tool-Aufruf / strukturierte Ausgaben benötigt werden

Verwende Ollama, wenn:

• Schnelles Setup benötigt wird

• Einzelbenutzer

• Weniger Ressourcen verfügbar sind

Nächste Schritte

• Ollama - Einfachere Alternative mit schnellerem Start

• DeepSeek-R1 - Leitfaden für das Reasoning-Modell

• DeepSeek-V3 - Bestes Allzweckmodell

• Qwen2.5 - Mehrsprachige Modelle

• Llama.cpp - Option mit geringerem VRAM