vLLM

Hochdurchsatz-LLM-Inferenz 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+. Neue Funktionen umfassen DeepSeek-R1-Unterstützung, strukturierte Ausgaben mit automatischer Werkzeugwahl, Multi-LoRA-Bereitstellung und verbesserte Speichereffizienz.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	16GB	32GB+
VRAM	16GB (7B)	24GB+
Netzwerk	500Mbps	1Gbps+
Startzeit	5–15 Minuten	-

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

Startzeit: Beim ersten Start wird das Modell von HuggingFace heruntergeladen (5–15 Minuten, abhängig von Modellgröße und Netzwerkgeschwindigkeit). HTTP 502 während dieser Zeit ist normal.

Warum vLLM?

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

• Produktionsreif - OpenAI-kompatible API sofort einsatzbereit

• Kontinuierliches Batching - Effizientes Serving für mehrere Benutzer

• Streaming - Echtzeit-Token-Generierung

• Multi-GPU - Tensorparallelismus für große Modelle

• Multi-LoRA - Gleichzeitiges Bereitstellen mehrerer feinabgestimmter Adapter (v0.7+)

• Strukturierte Ausgaben - JSON-Schema-Validierung und Tool-Calls (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:

# Prüfe Gesundheit (kann beim ersten Lauf 5–15 Min dauern)
curl https://your-http-pub.clorecloud.net/health

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

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

1. Server hat 16GB+ RAM

2. Server hat genug VRAM für das Modell

3. HuggingFace-Token ist für gesperrte Modelle gesetzt

Zugriff auf Ihren Dienst

Bei Bereitstellung auf CLORE.AI greifen Sie auf vLLM über die http_pub URL:

# 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 Die untenstehenden Beispiele funktionieren, wenn über SSH verbunden. Für externen Zugriff ersetzen Sie durch Ihre https://your-http-pub.clorecloud.net/ URL.

Installation

Verwendung von 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

Verwendung von 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	Benötigter VRAM	Benötigter RAM
Mistral 7B	7B	14GB	16GB+
Llama 3.1 8B	8B	16GB	16GB+
Llama 3.1 70B	70B	140GB (oder 2x80GB)	64GB+
Mixtral 8x7B	47B	90GB	32GB+
Qwen2.5 7B	7B	14GB	16GB+
Qwen2.5 72B	72B	145GB	64GB+
DeepSeek-V3	236B MoE	Multi-GPU	128GB+
DeepSeek-R1-Distill-Qwen-7B	7B	14GB	16GB+
DeepSeek-R1-Distill-Qwen-32B	32B	64GB	32GB+
DeepSeek-R1-Distill-Llama-70B	70B	140GB	64GB+
Phi-4	14B	28GB	32GB+
Gemma 2 9B	9B	18GB	16GB+
CodeLlama 34B	34B	68GB	32GB+

Serveroptionen

Basiser Server

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 (geringerer 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-Calls (v0.7+)

Automatische Werkzeugwahl und strukturierte JSON-Ausgaben aktivieren:

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": "Hole die aktuelle Wetterlage für eine Stadt",
            "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-Call 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 via response_format:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Extrahiere: John Smith, 30 Jahre alt, Softwareingenieur"}],
    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-Serving (v0.7+)

Stellen Sie ein Basismodell mit mehreren LoRA-Adaptern gleichzeitig 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

Einen bestimmten LoRA-Adapter per Modellnamen abfragen:

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

# Verwende den Code-Adapter
response = client.chat.completions.create(
    model="code-adapter",
    messages=[{"role": "user", "content": "Schreibe eine Python-Funktion, um eine Liste zu sortieren"}]
)

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

vLLM v0.7+ hat native Unterstützung für DeepSeek-R1-Distillmodelle. Diese reasoning-Modelle erzeugen <think> Tags, die ihren Denkprozess anzeigen.

DeepSeek-R1-Distill-Qwen-7B (Single 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 fährt, wie hoch ist seine Geschwindigkeit in m/s?"
        }
    ],
    max_tokens=2048,
    temperature=0.6
)

content = response.choices[0].message.content
# Antwort enthält <think>...</think>-Denkblock gefolgt von der Antwort
print(content)

Think-Tags parsen:

import re

def parse_deepseek_r1_response(content: str) -> dict:
    """Extrahiere Denken und Antwort aus einer DeepSeek-R1-Antwort."""
    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("Thinking:", result["thinking"][:200], "...")
print("Answer:", 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="nicht benötigt"
)

# 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": "Hallo!"}],
    "max_tokens": 100
  }'

Textvervollstä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 plus zusätzliche Dienstendpunkte.

Standardendpunkte

Endpunkt	Methode	Beschreibung
/v1/models	GET	Verfügbare Modelle auflisten
/v1/chat/completions	POST	Chat-Vervollständigung
/v1/completions	POST	Textvervollständigung
/health	GET	Health-Check (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 zum Zählen von Tokens vor dem Senden von Anfragen:

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]}

Detokenize

Token-IDs zurück in Text konvertieren:

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

Öffnen Sie im Browser für interaktive API-Dokumentation:

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

Prometheus-Metriken

Zur Überwachung:

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 finalen Antwort zeigen.

Benchmarks

Durchsatz (Tokens/Sek pro Benutzer)

Modell	RTX 3090	RTX 4090	A100 40GB	A100 80GB
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 Januar 2026.

Kontextlänge vs. VRAM

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

Hugging Face Authentifizierung

Für gesperrte 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	16GB	16GB	24GB VRAM, 32GB RAM
13B	26GB	32GB	40GB VRAM
34B	70GB	32GB	80GB VRAM
70B	140GB	64GB	2x80GB

Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

GPU	VRAM	Preis/Tag	Am besten geeignet für
RTX 3090	24GB	$0.30–1.00	7-8B-Modelle
RTX 4090	24GB	$0.50–2.00	7-13B, schnell
A100	40GB	$1.50–3.00	13-34B-Modelle
A100	80GB	$2.00–4.00	34-70B-Modelle

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

Fehlerbehebung

HTTP 502 über lange Zeit

1. Prüfe RAM: Server muss 16GB+ RAM haben

2. Prüfe VRAM: Muss in das Modell passen

3. Modell-Download: Beim ersten Lauf wird von HuggingFace heruntergeladen (5–15 Min)

4. HF-Token: Gesperrte Modelle erfordern Authentifizierung

Kein Speicher mehr

# Speicherverbrauch 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	Gering	Mittel
Benutzerfreundlichkeit	Mittel	Mittel	Einfach
Startzeit	5–15 min	1–2 Min	30 Sek.
Multi-GPU	Nativ	Begrenzt	Begrenzt
Tool-Aufrufe	Ja (v0.7+)	Begrenzt	Begrenzt
Multi-LoRA	Ja (v0.7+)	Nein	Nein

Verwenden Sie vLLM, wenn:

• Hoher Durchsatz Priorität hat

• Mehrere Benutzer bedient werden sollen

• Genug VRAM und RAM vorhanden sind

• Produktionsbereitstellung

• Tool-Calls / strukturierte Ausgaben benötigt werden

Verwenden Sie Ollama, wenn:

• Schnelle Einrichtung benötigt wird

• Einzelner Benutzer

• Weniger Ressourcen verfügbar sind

Nächste Schritte

• Ollama - Einfachere Alternative mit schnellerem Start

• DeepSeek-R1 - Leitfaden für Reasoning-Modelle

• DeepSeek-V3 - Bestes Generalmodell

• Qwen2.5 - Mehrsprachige Modelle

• Llama.cpp - Option mit geringerem VRAM