> 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 Triton Inference Server**

TensorRT-LLM ist NVIDIAs Open-Source-Bibliothek zur Optimierung der Inferenz von Large Language Models auf NVIDIA-GPUs. Sie liefert erstklassige Leistung durch Kernel-Fusion, Quantisierung (INT4, INT8, FP8), In-Flight-Batching und paged KV-Caching. In Kombination mit 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                     | Ausgezeichnet | Best in class |
| Latenz                        | Gut           | Ausgezeichnet |
| INT4/INT8-Quantisierung       | Teilweise     | Native        |
| FP8-Unterstützung             | Begrenzt      | Vollständig   |
| Multi-GPU Tensor-Parallelität | Ja            | Ja            |
| Einrichtungsaufwand           | Niedrig       | Mittel–Hoch   |

{% hint style="success" %}
**TensorRT-LLM liefert typischerweise 2–4x höheren Durchsatz** im Vergleich zur Standard-HuggingFace-transformers-Inferenz und 30–50% besseren Durchsatz als vLLM für Batch-Serving-Szenarien.
{% endhint %}

***

## Voraussetzungen

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

***

## VRAM-Anforderungen nach Modell

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

***

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

1. Melden Sie sich an bei [clore.ai](https://clore.ai) → **Marktplatz**
2. **Für Single-GPU-Serving (7B–13B-Modelle):** RTX 4090 24GB oder RTX 3090 24GB
3. **Für große Modelle (70B+):** Mehrere A100 80GB oder H100

{% hint style="info" %}
**Multi-GPU-Strategie:**

* 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 aufgeführten GPUs im Clore.ai-Marktplatz
  {% endhint %}

***

## Schritt 2 — Deployen Sie Triton Inference Server mit TRT-LLM-Backend

**Docker-Image:**

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

{% hint style="warning" %}
Verwenden Sie die `-trtllm-python-py3` Variante — dies beinhaltet das TensorRT-LLM-Backend vorinstalliert. Der Tag entspricht der NVIDIA-Container-Version (24.01 = Januar 2024). Prüfen Sie [NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver/tags) auf den neuesten Tag.
{% endhint %}

**Offengelegte 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 verifizieren

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

# GPU prüfen
nvidia-smi

# TensorRT-Version prü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 Pfade für Ihr gewähltes Modell an.

### Installieren Sie HuggingFace CLI

```bash
pip install huggingface_hub
huggingface-cli login
# Geben Sie Ihr HuggingFace-Token ein, wenn Sie dazu aufgefordert werden
```

### 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 verwenden Sie snapshot_download
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 bauen

Dies ist der entscheidende Schritt — das Kompilieren des Modells zu einer optimierten TensorRT-Engine.

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

```bash
cd /workspace

# HuggingFace-Gewichte in 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 bauen
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 / Minimale Speicheranforderung)

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

# Zu 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" %}
**Build-Zeit der Engine:** 10–30 Minuten je nach GPU und Modellgröße. Dies ist ein einmaliger Vorgang — einmal gebaut, lädt die Engine in Sekunden.
{% endhint %}

***

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

Überprüfen Sie vor dem Einrichten von Triton, 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 = "What is the capital of France?"
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"Response: {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
```

### Engine-Symlink 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 Serverstart warten
sleep 30

# Server-Gesundheit prü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:"))
```

### Benchmark-Durchsatz

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

# Performance-Benchmark 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-kompatible 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 \        # Reduzieren von 32
    --max_input_len 2048 \      # Reduzieren von 4096
    --max_seq_len 4096          # Reduzieren von 8192
```

### Triton-Server startet nicht

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

# Überprüfen Sie, ob 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 Konkurenz erhöhen
# Passen Sie max_tokens_in_paged_kv_cache basierend auf verfügbarem VRAM an
```

***

## Performance-Benchmarks auf Clore.ai-GPUs

| Modell        | GPU         | Quantisierung | Durchsatz (Tokens/Sekunde) |
| ------------- | ----------- | ------------- | -------------------------- |
| 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                    |

***

## Weitere 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 produktives LLM-Serving, wenn Durchsatz und Latenz kritisch sind. Für einfachere Setups ziehen Sie den vLLM-Leitfaden in Betracht.*

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall       | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| -------------------- | --------------- | ------------------------------ |
| Entwicklung/Tests    | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Produktions-Inferenz | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |
| Große Modelle (70B+) | A100 80GB       | \~$1.20/gpu/hr                 |

> 💡 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:

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

The question should be specific, self-contained, and written in natural language.
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.