> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/gpu-devops/tensorrt-llm.md).

# TensorRT-LLM

> **Maximaler LLM-Inferenzdurchsatz mit NVIDIA TensorRT-Optimierung — bereitgestellt über den Triton Inference Server**

TensorRT-LLM ist die Open-Source-Bibliothek von NVIDIA zur Optimierung der Inferenz großer Sprachmodelle auf NVIDIA-GPUs. Sie liefert Spitzenleistung durch Kernel-Fusion, Quantisierung (INT4, INT8, FP8), In-Flight-Batching und paged KV-Caching. In Kombination mit dem Triton Inference Server erhalten Sie eine produktionsreife Serving-Infrastruktur.

**GitHub:** [NVIDIA/TensorRT-LLM](https://github.com/NVIDIA/TensorRT-LLM) — 10K+ ⭐

***

## Warum TensorRT-LLM?

| Funktion                     | vLLM         | TensorRT-LLM |
| ---------------------------- | ------------ | ------------ |
| Durchsatz                    | Hervorragend | Klassenbeste |
| Latenz                       | Gut          | Hervorragend |
| INT4/INT8-Quantisierung      | Teilweise    | Nativ        |
| FP8-Unterstützung            | Begrenzt     | Vollständig  |
| Multi-GPU-Tensorparallelität | Ja           | Ja           |
| Einrichtungsaufwand          | Niedrig      | Mittel-Hoch  |

{% hint style="success" %}
**TensorRT-LLM liefert typischerweise einen 2–4x höheren Durchsatz** im Vergleich zur standardmäßigen HuggingFace-Transformers-Inferenz und 30–50 % besseren Durchsatz als vLLM in Batch-Serving-Szenarien.
{% endhint %}

***

## Voraussetzungen

* Clore.ai-Konto mit GPU-Miete
* **NVIDIA-GPU mit Ampere-Architektur oder neuer** (RTX 3090, A100, RTX 4090, H100)
* Grundkenntnisse in Linux und Docker
* Ausreichend VRAM für Ihr ausgewähltes Modell

***

## VRAM-Anforderungen nach Modell

| Modell        | FP16   | INT8  | INT4  |
| ------------- | ------ | ----- | ----- |
| Llama-3.1 8B  | 16 GB  | 8 GB  | 4 GB  |
| Llama-3.1 70B | 140 GB | 70GB  | 35GB  |
| Mistral 7B    | 14GB   | 7GB   | 4 GB  |
| Mixtral 8x7B  | 90 GB  | 45 GB | 24 GB |
| Qwen2.5 72B   | 144GB  | 72GB  | 36GB  |

***

## Schritt 1 — Wählen Sie Ihre GPU auf Clore.ai

1. Melde dich an bei [clore.ai](https://clore.ai) → **Marktplatz**
2. **Für Bereitstellung mit einer einzelnen GPU (Modelle 7B–13B):** RTX 4090 24GB oder RTX 3090 24GB
3. **Für große Modelle (70B+):** Mehrere A100 80GB oder H100

{% hint style="info" %}
**Strategie mit mehreren GPUs:**

* 2x A100 80GB → Llama 3.1 70B in FP16 oder Qwen2.5 72B
* 4x A100 80GB → Llama 3.1 405B in INT8
* Wählen Sie Server mit mehreren GPUs aus, die im Clore.ai-Marktplatz aufgeführt sind
  {% endhint %}

***

## Schritt 2 — Stellen Sie den Triton Inference Server mit dem TRT-LLM-Backend bereit

**Docker-Image:**

```
nvcr.io/nvidia/tritonserver:24.01-trtllm-python-py3
```

{% hint style="warning" %}
Nutzen Sie den `-trtllm-python-py3` Variante — dies enthält das TensorRT-LLM-Backend vorinstalliert. Das Tag entspricht der NVIDIA-Containerveröffentlichung (24.01 = Januar 2024). Prüfen Sie [NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver/tags) für das neueste Tag.
{% endhint %}

**Freigegebene Ports:**

```
22
8000
```

**Umgebungsvariablen:**

```
NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
TRANSFORMERS_CACHE=/workspace/hf_cache
HF_HOME=/workspace/hf_cache
```

**Volume/Festplatte:** Mindestens 100GB empfohlen

***

## Schritt 3 — Verbinden und Installation überprüfen

```bash
ssh root@<server-ip> -p <ssh-port>

# GPU überprüfen
nvidia-smi

# TensorRT-Version überprüfen
python3 -c "import tensorrt_llm; print(tensorrt_llm.__version__)"

# Prüfen, ob Triton verfügbar ist
tritonserver --version
```

***

## Schritt 4 — Modell herunterladen und vorbereiten

Wir verwenden Llama 3.1 8B als Beispiel. Passen Sie die Pfade für Ihr ausgewähltes Modell an.

### HuggingFace-CLI installieren

```bash
pip install huggingface_hub
huggingface-cli login
# Geben Sie bei Aufforderung Ihr HuggingFace-Token ein
```

### Modellgewichte herunterladen

```bash
mkdir -p /workspace/models/llama-3.1-8b
huggingface-cli download \
    meta-llama/Llama-3.1-8B-Instruct \
    --local-dir /workspace/models/llama-3.1-8b \
    --local-dir-use-symlinks False

# Oder snapshot_download verwenden
python3 << 'EOF'
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id="meta-llama/Llama-3.1-8B-Instruct",
    local_dir="/workspace/models/llama-3.1-8b",
    local_dir_use_symlinks=False
)
EOF
```

***

## Schritt 5 — TensorRT-Engine erstellen

Dies ist der entscheidende Schritt — das Modell wird in eine optimierte TensorRT-Engine kompiliert.

### FP16-Engine (beste Qualität)

```bash
cd /workspace

# HuggingFace-Gewichte in das TRT-LLM-Format konvertieren
python3 /usr/local/lib/python3.10/dist-packages/tensorrt_llm/examples/llama/convert_checkpoint.py \
    --model_dir /workspace/models/llama-3.1-8b \
    --output_dir /workspace/trt_checkpoints/llama-3.1-8b-fp16 \
    --dtype float16 \\
    --tp_size 1

# TensorRT-Engine erstellen
trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-fp16 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-fp16 \
    --gemm_plugin float16 \
    --max_batch_size 32 \
    --max_input_len 4096 \
    --max_seq_len 8192 \
    --max_num_tokens 16384 \
    --use_paged_context_fmha enable
```

### INT8 SmoothQuant-Engine (höherer Durchsatz)

```bash
# Mit SmoothQuant-Quantisierung konvertieren
python3 /usr/local/lib/python3.10/dist-packages/tensorrt_llm/examples/llama/convert_checkpoint.py \
    --model_dir /workspace/models/llama-3.1-8b \
    --output_dir /workspace/trt_checkpoints/llama-3.1-8b-int8 \
    --dtype float16 \\
    --smoothquant 0.5 \
    --per_channel \
    --per_token

trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-int8 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-int8 \
    --gemm_plugin float16 \
    --smoothquant_plugin float16 \
    --max_batch_size 64 \
    --max_input_len 4096 \
    --max_seq_len 8192
```

### INT4 AWQ Engine (maximaler Durchsatz / minimaler Speicherbedarf)

```bash
# auto-gptq für die Quantisierung installieren
pip install autoawq

# In INT4 AWQ quantisieren
python3 << 'EOF'
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "/workspace/models/llama-3.1-8b"
quant_path = "/workspace/models/llama-3.1-8b-awq-int4"

model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM"
}
model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)
EOF

# AWQ in TRT-LLM konvertieren
python3 /usr/local/lib/python3.10/dist-packages/tensorrt_llm/examples/llama/convert_checkpoint.py \
    --model_dir /workspace/models/llama-3.1-8b-awq-int4 \
    --output_dir /workspace/trt_checkpoints/llama-3.1-8b-int4 \
    --dtype float16 \\
    --quant_ckpt_path /workspace/models/llama-3.1-8b-awq-int4 \
    --use_weight_only \
    --weight_only_precision int4_awq \
    --per_group

trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-int4 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-int4 \
    --gemm_plugin float16 \
    --max_batch_size 128 \
    --max_input_len 4096 \
    --max_seq_len 8192
```

{% hint style="info" %}
**Engine build time:** 10–30 Minuten je nach GPU und Modellgröße. Dies ist eine einmalige Operation — einmal erstellt, lädt sich die Engine in Sekunden.
{% endhint %}

***

## Schritt 6 — Schneller Test mit der TRT-LLM-Python-API

Bevor Sie Triton einrichten, überprüfen Sie, ob die Engine funktioniert:

```bash
python3 << 'EOF'
import tensorrt_llm
from tensorrt_llm.runtime import ModelRunner
from transformers import AutoTokenizer

engine_dir = "/workspace/trt_engines/llama-3.1-8b-fp16"
tokenizer_dir = "/workspace/models/llama-3.1-8b"

tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir)
runner = ModelRunner.from_dir(
    engine_dir=engine_dir,
    rank=0
)

prompt = "Was ist die Hauptstadt von Frankreich?"
input_ids = tokenizer.encode(prompt, return_tensors="pt")

output = runner.generate(
    batch_input_ids=[input_ids[0].tolist()],
    max_new_tokens=200,
    temperature=0.7,
    top_p=0.9
)

output_ids = output[0][0][len(input_ids[0]):]
response = tokenizer.decode(output_ids, skip_special_tokens=True)
print(f"Antwort: {response}")
EOF
```

***

## Schritt 7 — Triton Inference Server einrichten

### Modell-Repository-Struktur erstellen

```bash
mkdir -p /workspace/triton_model_repo/llama/1

# Modellkonfiguration erstellen
cat > /workspace/triton_model_repo/llama/config.pbtxt << 'EOF'
backend: "tensorrtllm"
name: "llama"
max_batch_size: 64
model_transaction_policy {
  decoupled: true
}

dynamic_batching {
  preferred_batch_size: [1, 2, 4, 8, 16, 32, 64]
  max_queue_delay_microseconds: 1000
}

input [
  {
    name: "input_ids"
    data_type: TYPE_INT32
    dims: [-1]
  },
  {
    name: "input_lengths"
    data_type: TYPE_INT32
    dims: [1]
    reshape: { shape: [] }
  },
  {
    name: "request_output_len"
    data_type: TYPE_INT32
    dims: [1]
    reshape: { shape: [] }
  },
  {
    name: "temperature"
    data_type: TYPE_FP32
    dims: [1]
    reshape: { shape: [] }
    optional: true
  }
]

output [
  {
    name: "output_ids"
    data_type: TYPE_INT32
    dims: [-1, -1]
  },
  {
    name: "sequence_length"
    data_type: TYPE_INT32
    dims: [1]
  }
]

instance_group [
  {
    count: 1
    kind: KIND_GPU
    gpus: [0]
  }
]

parameters: {
  key: "gpt_model_type"
  value: { string_value: "inflight_fused_batching" }
}

parameters: {
  key: "gpt_model_path"
  value: { string_value: "/workspace/trt_engines/llama-3.1-8b-fp16" }
}

parameters: {
  key: "max_tokens_in_paged_kv_cache"
  value: { string_value: "8192" }
}

parameters: {
  key: "batch_scheduler_policy"
  value: { string_value: "guaranteed_no_evict" }
}
EOF
```

### Symlink für die Engine erstellen

```bash
ln -s /workspace/trt_engines/llama-3.1-8b-fp16 \
    /workspace/triton_model_repo/llama/1/
```

### Triton Server starten

```bash
tritonserver \
    --model-repository=/workspace/triton_model_repo \
    --http-port=8000 \
    --grpc-port=8001 \
    --metrics-port=8002 \
    --log-verbose=0 &

# Auf den Serverstart warten
sleep 30

# Serverzustand überprüfen
curl -s http://localhost:8000/v2/health/ready
```

***

## Schritt 8 — Die API abfragen

### OpenAI-kompatibler Client

```python
import requests
import json

def generate(prompt: str, max_tokens: int = 200) -> str:
    url = "http://localhost:8000/v2/models/llama/generate"
    
    payload = {
        "text_input": prompt,
        "parameters": {
            "max_tokens": max_tokens,
            "temperature": 0.7,
            "top_p": 0.9
        }
    }
    
    response = requests.post(url, json=payload)
    result = response.json()
    return result.get("text_output", "")

# Test
print(generate("Erkläre Quantencomputing in einfachen Worten:"))
```

### Durchsatz benchmarken

```bash
# tritonclient installieren
pip install tritonclient[all]

# Leistungsbenchmark ausführen
perf_analyzer \
    -m llama \
    -u localhost:8001 \
    --protocol grpc \
    --input-data /workspace/sample_inputs.json \
    --concurrency-range 1:32:2 \
    --measurement-interval 10000 \
    --shape input_ids:512 \
    --shape input_lengths:1 \
    --shape request_output_len:1
```

***

## Schritt 9 — OpenAI-kompatiblen API-Wrapper hinzufügen

Zur einfacheren Integration fügen Sie einen FastAPI-Wrapper hinzu:

```bash
pip install fastapi uvicorn tritonclient[all]

cat > /workspace/openai_server.py << 'EOF'
from fastapi import FastAPI
from pydantic import BaseModel
import tritonclient.http as httpclient
import numpy as np
from transformers import AutoTokenizer

app = FastAPI()
tokenizer = AutoTokenizer.from_pretrained("/workspace/models/llama-3.1-8b")
client = httpclient.InferenceServerClient("localhost:8000")

class ChatRequest(BaseModel):
    model: str = "llama"
    messages: list
    max_tokens: int = 512
    temperature: float = 0.7

@app.post("/v1/chat/completions")
async def chat(req: ChatRequest):
    prompt = tokenizer.apply_chat_template(
        req.messages,
        tokenize=False,
        add_generation_prompt=True
    )
    
    input_ids = tokenizer.encode(prompt)
    
    inputs = [
        httpclient.InferInput("input_ids", [len(input_ids)], "INT32"),
        httpclient.InferInput("input_lengths", [1], "INT32"),
        httpclient.InferInput("request_output_len", [1], "INT32"),
    ]
    inputs[0].set_data_from_numpy(np.array(input_ids, dtype=np.int32))
    inputs[1].set_data_from_numpy(np.array([len(input_ids)], dtype=np.int32))
    inputs[2].set_data_from_numpy(np.array([req.max_tokens], dtype=np.int32))
    
    result = client.infer("llama", inputs)
    output_ids = result.as_numpy("output_ids")[0][len(input_ids):]
    text = tokenizer.decode(output_ids, skip_special_tokens=True)
    
    return {
        "choices": [{"message": {"role": "assistant", "content": text}}]
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)
EOF

python3 /workspace/openai_server.py &
```

***

## Fehlerbehebung

### Engine Build OOM

```bash
# max_batch_size und max_num_tokens reduzieren
trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-fp16 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-fp16 \
    --gemm_plugin float16 \
    --max_batch_size 8 \        # Von 32 reduzieren
    --max_input_len 2048 \      # Von 4096 reduzieren
    --max_seq_len 4096          # Von 8192 reduzieren
```

### Triton-Server startet nicht

```bash
# Protokolle prüfen
cat /workspace/triton.log

# Prüfen, ob die Engine-Dateien vorhanden sind
ls -la /workspace/trt_engines/llama-3.1-8b-fp16/

# GPU-Speicher prüfen
nvidia-smi
```

### Niedriger Durchsatz

```bash
# In-Flight-Batching aktivieren und die Parallelität erhöhen
# max_tokens_in_paged_kv_cache anhand des verfügbaren VRAM anpassen
```

***

## Leistungsbenchmarks auf Clore.ai-GPUs

| Modell        | GPU         | Quantisierung | Durchsatz (Tokens/Sek.) |
| ------------- | ----------- | ------------- | ----------------------- |
| Llama 3.1 8B  | RTX 4090    | FP16          | \~3,500                 |
| Llama 3.1 8B  | RTX 4090    | INT4 AWQ      | \~6,200                 |
| Llama 3.1 70B | 2x A100 80G | FP16          | \~1,800                 |
| Mixtral 8x7B  | 2x RTX 4090 | INT8          | \~2,400                 |

***

## Zusätzliche Ressourcen

* [TensorRT-LLM GitHub](https://github.com/NVIDIA/TensorRT-LLM)
* [Triton Inference Server](https://github.com/triton-inference-server/server)
* [NGC Container Registry](https://catalog.ngc.nvidia.com/)
* [TRT-LLM Dokumentation](https://nvidia.github.io/TensorRT-LLM/)
* [AWQ-Quantisierung](https://github.com/mit-han-lab/llm-awq)

***

*TensorRT-LLM auf Clore.ai ist die optimale Wahl für produktiven LLM-Betrieb, bei dem Durchsatz und Latenz entscheidend sind. Für einfachere Setups ziehen Sie den vLLM-Leitfaden in Betracht.*

***

## GPU-Empfehlungen für Clore.ai

{% hint style="warning" %}
**Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

| Anwendungsfall       | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai            |
| -------------------- | ---------------- | ----------------------------------------- |
| Entwicklung/Testen   | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde                    |
| Produktions-Inferenz | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde                    |
| Große Modelle (70B+) | A100 80GB        | [Bare Metal](https://clore.ai/bare-metal) |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/gpu-devops/tensorrt-llm.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.