Bauanleitung · Lokale KI-Infrastruktur · Ostfriesland

How to build a Zuse

Ein kompletter KI-Server aus Gebrauchtteilen: 27 Container, drei RTX 3090, 256.000 Token Kontext, 978 Token/s unter Last. Diese Anleitung ist alles, was ich beim Bauen gelernt habe — inklusive der Sachen, die nicht funktioniert haben.

~3.710 €GPU-Seite, gebraucht
72 GBVRAM @ 936 GB/s
69,5 → 978Token/s (1 → 64 parallel)
262.144Token Kontextfenster
27Container gleichzeitig
250 Wpro Karte, gecappt

Prolog: Es fing mit 8 GB an

Wie aus „der Laptop reicht schon noch" ein offenes Rig im Arbeitszimmer wurde.

Angefangen hat das alles nicht mit einer Vision, sondern mit einem Nadelöhr.

In meinem Arbeitsgerät, einem Lenovo P16v Gen 2, steckt eine NVIDIA RTX PRO 2000 Blackwell Laptop GPU. Dazu ein Core Ultra 9 285H mit 16 Kernen und 64 GB RAM. Auf dem Papier eine Maschine, mit der man arbeiten kann — und das kann man auch. Bis man anfängt, lokale Sprachmodelle ernst zu nehmen.

Denn die entscheidende Zahl auf diesem Gerät ist nicht die 64 im RAM-Feld. Es sind die 8 GB dedizierter Grafikspeicher. Der Task-Manager zeigt daneben freundlich „Gemeinsamer GPU-Speicher: 47,4 GB" an, und genau da liegt die Falle, auf die jeder einmal reinfällt: Das ist normaler Systemspeicher, den Windows der GPU bei Bedarf leiht. Er hängt am DDR5-Bus, nicht am GDDR7 der Karte. Ein Modell, das dorthin ausgelagert wird, läuft nicht „etwas langsamer". Es kriecht.

Die Zahl, die zählt

Ein Sprachmodell antwortet nur so schnell, wie sein Gewichtsspeicher gelesen werden kann. Passt es nicht in den dedizierten VRAM, ist die Rechenleistung der Karte egal.

In 8 GB bekommt man ein 7B-Modell in 4-bit unter, mit Mühe ein 14B. Das ist nett für Autovervollständigung. Es ist nichts, womit man eine Codebase umbaut, ein 200-seitiges Dokument zusammenfasst oder einen Agenten betreibt, der über zwanzig Schritte hinweg den Faden behält. Und ich wollte genau das — beruflich, nicht als Spielzeug.

Die naheliegende Antwort wäre gewesen: neue Hardware. Die ist 2026 aber absurd teuer geworden. Die Speicherkrise seit Ende 2025 hat DDR5 und NAND vervielfacht, weil die KI-Industrie die Fertigungskapazität für HBM leersaugt. Ein neuer Rechner mit ordentlich VRAM kostet inzwischen so viel wie ein gebrauchtes Auto.

Also die andere Antwort: gebrauchte Server- und GPU-Teile. Die Rechnung geht auf, und zwar deutlich. Was dabei rauskam, steht seitdem in meinem Arbeitszimmer, heißt Zuse, und diese Anleitung beschreibt, wie man es nachbaut.

Ich schreibe sie, weil in der Diskussion über lokale KI erstaunlich viel behauptet und erstaunlich wenig gemessen wird — in beide Richtungen. Es gibt die Fraktion, die glaubt, ein Mac Mini ersetze ein Enterprise-Abo. Und es gibt die Fraktion, die glaubt, eine Consumer-GPU unter Dauerlast gehe mit einem lauten Knall kaputt. Beide irren, und beide Irrtümer lassen sich mit einem Terminal und ein bisschen Geduld auflösen.

Alles hier ist reproduzierbar. Die Compose-Files sind die, die bei mir laufen. Die Zahlen kommen aus Messreihen, deren Fallstricke ich mitdokumentiere, weil ich in jeden einzelnen selbst reingetreten bin.


01Das Leitprinzip

Nicht die Menge des Speichers entscheidet über das Tempo, sondern seine Bandbreite.

Fast jede Diskussion über lokale KI dreht sich um Speichermenge: „128 GB, damit läuft ein 70B!" Das ist die halbe Wahrheit, und die falsche Hälfte.

Der Denkfehler steckt in der Funktionsweise der Textgenerierung. Ein dichtes Sprachmodell muss für jedes einzelne Token, das es schreibt, seine kompletten Gewichte einmal durch den Speicher lesen. Nicht einmal pro Antwort — einmal pro Wortteil. Damit ist die Generierungsgeschwindigkeit bandbreitenlimitiert, nicht rechenlimitiert.

Die Überschlagsrechnung: Ein 27B-Modell in 4-bit belegt rund 17 GB. Bei

Der Rest ist Overhead und Aufmerksamkeitsberechnung, aber das Verhältnis bleibt. Eine gebrauchte 3090 ist für Modelle, die in ihre 24 GB passen, schneller als jede Box mit mehr, aber langsamerem Speicher.

Merksatz

Kapazität entscheidet, welches Modell überhaupt lädt.
Bandbreite entscheidet, wie schnell es antwortet.

Für das Gefühl „das Ding reagiert flüssig" zählt die Bandbreite. Und genau deshalb schlägt ein Stapel gebrauchter Gaming-Karten die schicken Kisten mit dem großen Unified Memory. Man kauft nicht Gigabyte, man kauft Gigabyte pro Sekunde.

SPEICHERBANDBREITE — WAS DAS TEMPO BESTIMMT RTX 3090 (GDDR6X) 936 GB/s Mac Studio / DGX Spark 273 GB/s DDR5-Systemspeicher ~90 GB/s — hier landet „shared VRAM" NVMe-SSD ~7 GB/s — wenn das Modell hierhin ausweicht: Ende Maßstabsgetreu. Deshalb ist „48 GB shared" kein Ersatz für „24 GB dediziert".
Abb. 1 — Warum die 47,4 GB „gemeinsamer GPU-Speicher" im Task-Manager keine Lösung sind: sie liegen zwei Größenordnungen unter dem, was die Karte selbst kann.

02Die Einkaufsliste

Was Zuse tatsächlich gekostet hat — und wo man sinnvoll kleiner anfängt.

Zuse ist kein durchgeplantes Produkt, sondern über Monate gewachsen. Trotzdem lässt sich die GPU-Seite sauber beziffern:

PostenPreisNotiz
3× RTX 3090, gebraucht~2.700 €à ~900 €, 24 GB, GDDR6X
HP Z840 Workstation, gebraucht~680 €2× Xeon E5-2643 v3, 64 GB DDR4-ECC
Externes Mining-Rig (Rahmen)~50 €Alu-Profil, offen
3× PCIe-Riser-Kabel~120 €à ~40 €, Gen3 x16
Zweites Netzteil für die GPUs~160 €1 kW
Summe: 72 GB VRAM @ 936 GB/s~3.710 €—

Preisstand der Gebrauchtkäufe 2026. Die 3090 ist durch die Speicherkrise inzwischen eher bei 1.000–1.200 € — der Vergleich unten verschiebt sich dadurch, kippt aber nicht.
Nicht in der Tabelle, weil es bei mir herumlag, aber unverzichtbar: ein kräftiges Stück Erdungskabel (6 mm²) als gemeinsame Masse zwischen beiden Netzteilen plus Kabelschuhe — zusammen keine 10 €. Warum das nicht optional ist, steht in Abschnitt 3.

Zum Einordnen: Ein DGX Spark kostet 4.699 $ und liefert 273 GB/s. Für weniger Geld bekommt man hier 72 GB mit dem Dreieinhalbfachen an Bandbreite. Diese Konfiguration gibt es als Fertiggerät schlicht nicht.

Wichtig, bevor jemand losbestellt

In den Z840 passt nicht einmal eine 3090. Nicht, weil kein Slot frei wäre, sondern weil die Luftführung im Weg steht: Über den CPU-Kühlern und am Festplattenträger sitzen Kunststoff-Kanäle, die den Luftstrom dorthin lenken, wo er hin soll. Genau dort will auch die Karte hin.

Ausbauen könnte man die Kanäle. Dann kühlt man aber zwei Xeons und vier Platten schlechter, um eine Grafikkarte unterzubringen — ein schlechtes Geschäft. Deshalb hängen bei mir alle drei Karten extern im Rig, per Riser an den Mainboard-Slots, an einem eigenen Netzteil. Das ist ein kleines Bauprojekt (Abschnitt 3), kein „Karte reinstecken" — und man sollte es vor der Bestellung wissen.

Stufe 1 — der vernünftige Einstieg, ~1.900–2.100 €

Der Trick 2026 ist, keine neuen Speicherteile zu kaufen. Man nimmt eine ausgemusterte Workstation, in der CPU, RAM, Netzteil und Gehäuse bereits stecken. Server-DDR4-ECC ist ein völlig anderer, viel günstigerer Markt als DDR5 für Desktops.

PostenPreisNotiz
HP Z840 / Z640 o. ä., mit 128 GB RAM~680 €DDR4-ECC ist schon drin
RTX 3090, 24 GB, gebraucht~1.000–1.200 €das Herzstück
2 TB NVMe~200 €für OS und Modelle
Summe~1.900–2.100 €inkl. 128 GB RAM

Passende Basismaschinen: HP Z840/Z640, Dell Precision T7810/7910, Lenovo ThinkStation P710/P720. Dual-Xeon E5 v3/v4, viele DIMM- und PCIe-Slots.

Worauf man beim Gebrauchtkauf wirklich achten muss

GPU-Stromstecker
Workstation-Netzteile nutzen oft proprietäre PCIe-Kabel. Das passende Adapterkabel für genau dieses Modell besorgen. Nicht raten, nicht „sieht gleich aus".
Platz und Kühlung — der Punkt, den ich unterschätzt habe
Nicht nur die Slotlänge messen, sondern die Luftführung ansehen. In Workstations sitzen Kunststoffkanäle über den CPU-Kühlern und am Festplattenträger, die den Luftstrom lenken — und die stehen genau da, wo die Karte hin soll. Herausnehmen geht, kostet aber die Kühlung, für die die Maschine gebaut wurde. Bei mir hat das den Ausschlag fürs externe Rig gegeben, schon bei der ersten Karte.
DDR4 statt DDR5 — egal?
Ja, weitgehend. Die Modellarbeit passiert im VRAM. Der Systemspeicher hält Caches und Container.
Zwei CPUs bedeuten zwei NUMA-Knoten
Das wird später relevant, wenn man GPUs auf Sockel verteilt. Kein Problem, aber man sollte es wissen.

Sparvariante

Eine gebrauchte RTX 3060 mit 12 GB (~200–330 €) trägt Modelle bis etwa 14B. Das ist ein ehrlicher Einstieg, kostet aber die 24-GB-Klasse — und damit alles, was in diesem Artikel interessant wird.


03Stufe 0: Das Eisen

Offenes Rig, Riser, zweites Netzteil — und die Topologie-Falle, die kein Datenblatt erwähnt.

Stufe 0 · Hardware

Im Tower steckt keine einzige Grafikkarte. Alle drei 3090 stehen extern im Eigenbau-Rig und hängen über PCIe-Riser-Kabel an den Mainboard-Slots; ihren Strom bekommen sie aus einem eigenen Netzteil. Der Z840 selbst läuft mit offenem Deckel und beherbergt nur noch das, wofür er gebaut wurde: zwei CPUs, RAM und Platten.

Der Grund ist der aus Abschnitt 2 — die Luftkanäle über den CPU-Kühlern und am Festplattenträger stehen genau dort, wo eine 3090 hin müsste. Man kann sie herausnehmen; man verschlechtert damit aber die Kühlung der Bauteile, für die die Maschine konstruiert wurde. Externes Rig war die sauberere Antwort, und im Nachhinein ohnehin die richtige: Drei Karten hätten so oder so nie hineingepasst.

Was das Rig braucht

Der Punkt, an dem man Hardware zerstört: die gemeinsame Masse

Wer zwei Netzteile verwendet, muss ihre Massen miteinander verbinden. Das ist kein Feinschliff, sondern die Voraussetzung dafür, dass der Aufbau überhaupt heil bleibt.

Der Grund: Die Karte bezieht ihren Strom aus dem Rig-Netzteil, sitzt mit ihren Signalleitungen aber am Mainboard, das vom Workstation-Netzteil versorgt wird. Der Rückweg für diesen Strom sucht sich seinen Pfad — und wenn es keinen ordentlichen gibt, nimmt er die Massepins des PCIe-Steckplatzes und des Riser-Kabels. Die sind für Signale ausgelegt, nicht für Ausgleichsströme. Das Ergebnis reicht von sporadischen Fehlern, die man tagelang in der Software sucht, bis zu verschmorten Riser-Steckern.

Bei mir macht das ein Stück 6 mm² grün-gelbes Erdungskabel aus dem Hausbau, das noch herumlag: fest verschraubt zwischen dem Massepunkt des Rig-Netzteils und dem Gehäuse der Workstation. Großzügig dimensioniert, und genau so soll es sein — dieser Leiter muss der bequemste Weg sein, den der Strom finden kann, deutlich bequemer als über die Riser.

Zwei Dinge gehören dazu, und man sollte sie nicht verwechseln:

  • Masseverbindung (das Kabel oben) — verbindet die Minus-Seiten beider Netzteile niederohmig miteinander.
  • Schutzleiter — beide Netzteile gehören an dieselbe Steckdosenleiste, damit sie auf demselben Erdpotential liegen. An der 230-V-Seite selbst wird nichts gebastelt.

Der Add2PSU-Adapter aus dem vorigen Punkt erledigt das nicht. Er schaltet nur ein Signal durch und führt eine dünne Signalmasse — Leistung fließt darüber nicht. Beides ist nötig: der Adapter fürs gemeinsame Anlaufen, das dicke Kabel für die Masse.

Die Falle, die mich Tage gekostet hat

Der Intel-C612-Chipsatz des Z840 blockt PCIe-Peer-to-Peer kategorisch. nvidia-smi topo -m zeigt zwischen den Karten CNS — „Chipset not supported". Die Karten können also nicht direkt miteinander reden, jede Kommunikation läuft über den Host-RAM.

Konsequenz: vLLM deaktiviert seinen Custom-AllReduce dauerhaft, NCCL staged über den Systemspeicher. Der Effekt ist kleiner, als man fürchtet — beim Generieren (bandbreitengebunden) praktisch null, beim Prefill und breitem Batching etwa 5 % längere Wartezeit bis zum ersten Token. Behebbar wäre es nur mit einer NVLink-Brücke. Ich lebe damit.

Wie die Karten verteilt sind

Zwei CPUs heißen zwei NUMA-Knoten, und die GPU-Verteilung folgt dem. Die beiden Karten, die zusammenarbeiten müssen, sitzen am selben Knoten:

HP Z840 · 2× XEON E5-2643 v3 · 60 GB DDR4-ECC NUMA 0 — CPU 1 RTX 3090 #0 03:00.0 · ~22 GB RTX 3090 #1 04:00.0 · ~22 GB ↕ PHB — selbe Host-Bridge vLLM · Tensor-Parallel = 2 ein Modell über beide Karten, 48 GB nutzbar NUMA 1 — CPU 2 RTX 3090 #2 84:00.0 · ~20 GB Founders Edition, 350 W HW-Limit Bildgenerierung · Embeddings · TTS läuft solo, kein Tensor-Parallel nötig SYS · über QPI · P2P vom Chipsatz geblockt (CNS) Extern im offenen Rig, alle drei Karten an Riser-Kabeln · eigenes 1-kW-Netzteil Im Tower nur CPUs, RAM, Platten — die Luftkanäle blockieren jeden GPU-Slot · PCIe Gen3 x16 liegt voll an
Abb. 2 — Die beiden Karten, die sich ein Modell teilen, hängen am selben NUMA-Knoten. Die dritte macht solo Bild, Sprache und Embeddings — für sie ist der geblockte P2P-Pfad irrelevant.
Kleinigkeit am Rande

Karte #2 ist eine Founders Edition, die anderen beiden sind Gigabyte Gaming OC. Das hat zwei Folgen: Die FE hat kein adressierbares RGB (man kann sie nicht mit den anderen grün leuchten lassen — ich habe das durchdebuggt, alle i²c-Busse der Karte sind leer), und sie hat ein Hardware-Limit von 350 W statt 390 W. Wer per Skript ein gemeinsames Power-Limit setzt, muss sich am kleinsten Wert orientieren.


04Stufe 1: Das Fundament

Ubuntu, Treiber, Docker — und vier Konventionen, die den Unterschied zwischen Server und Kartenhaus machen.

Stufe 1 · OS & Container

Ab hier ist alles hardwareunabhängig. Auf Zuse läuft Ubuntu 26.04 LTS mit Kernel 7.0, headless, feste LAN-IP. Das Betriebssystem und die Modelle liegen auf SSD, die Daten auf Platten.

Treiber + Container-Toolkit — der ganze Setup-Aufwand
# NVIDIA-Treiber
sudo ubuntu-drivers autoinstall
sudo reboot
nvidia-smi          # muss die Karte(n) mit 24576 MiB zeigen

# Docker
curl -fsSL https://get.docker.com | sh

# NVIDIA Container Toolkit — damit Container die GPU sehen
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Der Beweis, dass das Fundament steht:
sudo docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi

Zeigt das letzte Kommando die Karte im Container, ist der schwierige Teil vorbei. Alles Weitere sind Compose-Files.

Die vier Konventionen

Der gesamte Stack — 27 Container — folgt vier Regeln. Sie klingen banal. Sie sind der Grund, warum ich einzelne Dienste seit Monaten neu starten, ersetzen und kaputtmachen kann, ohne dass der Rest es merkt.

Regel 1 — ein Dienst, ein Compose-File

Jeder Dienst liegt unter /data/docker/<name>/docker-compose.yml und ist für sich deploybar. Kein Mega-Compose, das alles gleichzeitig hochzieht oder gleichzeitig stirbt.

Regel 2 — Container reden über den Host, nicht über ein gemeinsames Netz

Jede Verbindung geht über host.docker.internal:<port>, dazu extra_hosts: ["host.docker.internal:host-gateway"]. Kein gemeinsames Docker-Netzwerk. Das entkoppelt alles: Jeder Dienst ist ein Port, egal ob er in Docker läuft, nativ auf dem Host oder auf einer anderen Maschine. Umzüge kosten eine Zeile.

Regel 3 — Modelle und Caches auf die schnelle SSD

/opt/models/<dienst>/. Ein Modell-Cache auf einer Festplatte ist ein Fehler, der sich bei jedem Containerstart rächt. Ich habe ihn gemacht, einmal.

Regel 4 — jeder Container restart: unless-stopped

Damit kommt nach einem Reboot alles von allein hoch. Mit einer Bedingung, die niemand erwartet — siehe gleich unten.

Die Reboot-Regel, die keiner glaubt

Container vor einem Reboot NICHT stoppen. Ein manuelles docker stop setzt eine Markierung „vom Benutzer gestoppt", die unless-stopped über den Neustart hinweg respektiert. Ich habe vor einem Reboot einmal brav alles heruntergefahren und danach 22 tote Container vorgefunden.

Richtig ist: einfach sudo reboot. Systemd beendet Docker sauber, Docker startet beim Boot alles wieder. Falls doch passiert: docker start $(docker ps -aq --filter status=exited).


05Stufe 2: Das Modell

vLLM, 27B in int4 über zwei Karten, 256.000 Token Kontext. Jedes Flag hat einen Grund.

Stufe 2 · Inferenz

Das Herzstück. Ich fahre vLLM, nicht Ollama oder llama.cpp — weil vLLM als einziges sauber mehrere gleichzeitige Anfragen bedient (Continuous Batching, PagedAttention) und Tensor-Parallelität über mehrere Karten beherrscht. Genau die zwei Eigenschaften machen aus einer Bastelkiste einen Server, an dem mehr als eine Person sitzen kann.

Das Modell ist Qwen3.8-27B als int4-AutoRound — quantisiert habe ich es selbst, auf diesen Karten (Abschnitt 12). Es liegt öffentlich auf Hugging Face.

/data/docker/vllm/docker-compose.yml — läuft genau so
services:
  vllm:
    image: vllm/vllm-openai:v0.27.1   # Tag pinnen, nicht :latest
    container_name: vllm
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - /opt/models:/opt/models
      - /opt/models/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
      - HF_HOME=/root/.cache/huggingface
      - VLLM_USE_FLASHINFER_SAMPLER=1
      # Gegen Allocator-Fragmentierung. Teil des OOM-Fixes, siehe unten.
      - PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
    ipc: host
    shm_size: "16g"
    command:
      - --model
      - /opt/models/Qwen3.8-27B-int4-AutoRound
      - --served-model-name
      - qwen3.8-27b
      - qwen3.6-27b            # Zweitname: alte Clients laufen weiter
      - --quantization
      - auto_round
      - --tensor-parallel-size
      - "2"                    # ein Modell über zwei Karten
      - --max-model-len
      - "262144"               # 256K Kontext
      - --kv-cache-dtype
      - fp8                    # halbiert den KV-Cache → doppelter Kontext
      - --gpu-memory-utilization
      - "0.95"                 # NICHT höher. Siehe Warnung.
      - --enable-prefix-caching
      - --enable-chunked-prefill
      - --trust-remote-code
      - --reasoning-parser
      - qwen3
      - --enable-auto-tool-choice
      - --tool-call-parser
      - qwen3_coder
      - --limit-mm-per-prompt
      - '{"image":4,"video":1}'  # Bilder/Video: das Modell kann das selbst
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ['0', '1']   # Karte 2 bleibt für anderes frei
              capabilities: [gpu]
    healthcheck:
      test: ["CMD-SHELL", "curl -fsS http://localhost:8000/health || exit 1"]
      interval: 30s
      start_period: 600s     # der erste Start dauert wirklich so lange

Warum diese Flags

--tensor-parallel-size 2
Das Modell wird über beide Karten geschnitten, damit stehen 48 GB statt 24 GB zur Verfügung. Das ist der Grund, warum 256K Kontext überhaupt möglich sind — die Gewichte belegen nur ~17 GB, der Rest ist KV-Cache.
--kv-cache-dtype fp8
Der Zwischenspeicher für den Gesprächsverlauf in 8 statt 16 bit. Halbiert seinen Bedarf, verdoppelt effektiv den möglichen Kontext. Die Rechnung für dieses Modell: 64 Layer, aber nur jeder vierte ist echte Full Attention (16 Stück). 16 × 2 × 4 KV-Köpfe × 256 Head-Dim × 1 Byte = 32 KiB pro Token. Ohne fp8 das Doppelte.
--enable-prefix-caching
Der mit Abstand wichtigste Schalter für den Alltag. Wiederholte Prompt-Anfänge werden nicht neu gelesen. Wie gewaltig das ist, steht in Abschnitt 11: 155 Sekunden gegen 1,9 Sekunden.
--served-model-name zweimal
Ein Alias-Trick. Beim Modellwechsel bekommt die neue Instanz zusätzlich den alten Namen, dann müssen nicht zwölf Clients gleichzeitig umkonfiguriert werden.
Der Fehler, der mir die Maschine um 8 Uhr morgens zerlegt hat

--gpu-memory-utilization 0.98 sieht aus wie „das Letzte rausholen". In Wahrheit blieben damit nur noch ~480 MB Luft. Ergebnis: Die Engine starb mitten im Betrieb an einem Out-of-Memory, und zurück blieb ein Zombie-Container — Status Up (unhealthy), also kein Auto-Restart, aber auch keine Antworten mehr.

Die Lösung war 0.95 plus expandable_segments:True. Das kostet nichts: Die 256K Kontext bleiben erhalten, ~2 GB Reserve pro Karte sind der Preis für einen Server, der morgens noch läuft.

Verifizieren, nicht glauben

vLLMs /v1/models meldet für dieses Modell has_vision: false. Das ist irreführend — es ist ein oberflächlicher Berechtigungs-Check, kein Fähigkeitstest. Das Modell beschreibt Screenshots völlig korrekt, inklusive abgelesener Zahlenwerte. Ich habe das einmal falsch dokumentiert, weil ich dem Endpunkt geglaubt habe. Bei Modellfähigkeiten hilft nur der echte Test.

Variante: dasselbe Modell auf einer Karte

Weil mich das jemand konkret gefragt hat, habe ich es durchgemessen. Es geht — mit einem entscheidenden Flag.

LaufKonfigurationGewichteCUDA-GraphsKVToken
Anaiv: util 0.95, Defaults17,45 GiB——OOM
Butil 0.97, max-num-seqs 417,450,482,9583.285
Cwie B, aber seqs 217,450,432,9783.285
Dwie B, Vision aus16,590,483,2992.842
Efinal: max-model-len 8192017,450,482,9584.696

Gemessen auf einer RTX 3090, vLLM v0.20.1. Alle Werte in GiB.

Der eine große Hebel ist --max-num-seqs 4. Er deckelt, wie viele CUDA-Graphen vLLM beim Start aufzeichnet. Mit Standardwerten sind das 3,0 GiB pro Karte — mit dem Deckel 0,48 GiB. Die gesparten 2,5 GiB sind rund 78.000 Token Kontext. Ohne dieses Flag stirbt der naive Start im Profiling (Lauf A), und man sucht den Fehler beim Modell.

Zwei Ergebnisse, die ich nicht erwartet hätte: Noch kleinere Werte bringen nichts mehr (B und C sind identisch, der Rest sind fixe Kosten). Und Vision ist billig — 0,86 GiB Gewichte und ~9.600 Token KV. Man muss die Bildfähigkeit nicht opfern, um Kontext zu gewinnen.

Tempo auf einer Karte: 45,8 Token/s solo bei 350 W, 159 Token/s gesamt bei vier parallelen Anfragen. Zum Vergleich die zwei Karten mit Tensor-Parallel: 69,5 Token/s solo — und 533.327 statt 84.696 Token Kontext.


06Stufe 3: Chat und Dokumente

Eine Oberfläche, eine richtige Datenbank, und der Unterbau, der aus einem Chat eine Dokumentensuche macht.

Stufe 3 · Oberfläche & RAG

Ein API-Endpunkt ist noch kein System. Was fehlt, ist eine Oberfläche, in der auch jemand arbeiten kann, der kein Terminal aufmacht — bei mir meine Frau, die den Server für ihre Arbeit nutzt. Dafür läuft Open-WebUI.

Wichtig ist, was hinter dieser Oberfläche passiert — und das ist der Punkt, an dem die meisten Darstellungen (auch meine erste) zu einfach werden. Es gibt hier nämlich zwei getrennte Wege durch dasselbe Chatfenster:

  1. Der direkte Weg. Man wählt das Modell, und die Oberfläche spricht das Sprachmodell selbst an. Dokumentensuche und Websuche macht in diesem Fall Open-WebUI mit seinem eigenen RAG-Unterbau.
  2. Der Agentenweg. Man wählt statt eines Modells den eigenen Agenten. Dann geht die Anfrage nicht ans Modell, sondern an eine Agenten-Instanz mit eigenen Werkzeugen, eigenem Gedächtnis und eigenem Zustand — die ihrerseits das Modell benutzt.

Der zweite Weg ist der, den ich im Alltag fast ausschließlich nutze. Und er ist der Grund, warum hier zwei Agenten-Instanzen laufen statt einer.

Browser · Telegram zwei Menschen, ein Server Open-WebUI :8081 — Chat, Nutzer, Dateien PostgreSQL App-Datenbank ① direkter Weg ② Agentenweg — Pipe routet nach Benutzer Proxy :8011 — setzt ein Flag Agent A — ich :8642 eigenes Gedächtnis Agent B — sie :8643 eigenes Gedächtnis Plugins A Kanon-Suche · Recherche Bild · Dateien · Sprachcheck Plugins B Kapitel-Lader · Recherche Bild · Dateien · Sprachcheck vLLM :8000 — GPU 0+1 ein Modell für alle Infinity :7997 Embed + Rerank Tika :9998 PDF + OCR SearXNG :8080 Websuche Firecrawl :3002 Volltext-Extraktion für die Recherche Jede Verbindung: host.docker.internal:<port> — kein gemeinsames Docker-Netz
Abb. 3 — Zwei Wege durch dieselbe Oberfläche. Grün der direkte Weg zum Modell mit dem RAG-Unterbau der Oberfläche, orange der Agentenweg: Die Pipe entscheidet anhand des angemeldeten Benutzers, welche der beiden Instanzen antwortet. Beide Agenten benutzen dasselbe Sprachmodell — aber niemals dieselben Werkzeuge und niemals dasselbe Gedächtnis.

Die Bausteine

Open-WebUI (:8081)
Chat-Oberfläche, Benutzerverwaltung, Dokumenten-Sammlungen, Sprachein- und -ausgabe. Spricht mit allem über OpenAI-kompatible Schnittstellen.
PostgreSQL
Die App-Datenbank. Wichtige Erfahrung: Mit dem mitgelieferten SQLite bekommt man bei mehreren gleichzeitigen Nutzern regelmäßig „database is locked". Der Umstieg auf Postgres hat das Problem restlos beseitigt. Hier liegen übrigens auch die Pipe und die Filter — sie sind Datenbankinhalt, kein Dateisystem-Inhalt, was beim Sichern gern vergessen wird.
Ein winziger Proxy davor (:8011)
Auf dem direkten Weg zeigt die Oberfläche nicht auf das Sprachmodell, sondern auf einen 25-Zeilen-Proxy, der jeder Anfrage ein einzelnes Feld hinzufügt: die Abschaltung des internen „Nachdenkens". Ohne das grübelt das Modell bei jedem einzelnen Turn sichtbar vor sich hin. Der Umweg existiert, weil verschiedene Clients dieses Flag in verschiedenen Dialekten senden — und der Server ignoriert alle bis auf einen. Ein Proxy war die ehrlichere Lösung, als in fremdem Code herumzupatchen.
Die Pipe — der eigentliche Trick
Eine Erweiterungsfunktion in der Oberfläche, die als eigenes „Modell" in der Auswahlliste auftaucht. Wählt man sie, schickt sie die Anfrage nicht an das Sprachmodell, sondern anhand der E-Mail-Adresse des angemeldeten Benutzers an die richtige Agenten-Instanz. Sie reicht dabei nicht einfach durch: Sie legt einen Auftrag an, pollt dessen Fortschritt und meldet Zwischenstände zurück ins Chatfenster — ein Agentenlauf mit Werkzeugaufrufen dauert eben länger als eine Modellantwort.
Infinity (:7997)
Embeddings (bge-m3) und Reranking (bge-reranker-v2-m3) auf Karte 2, ~3 GB VRAM. Der Reranker ist der Unterschied zwischen „findet irgendwas Ähnliches" und „findet die richtige Stelle".
Tika (:9998)
Zieht Text aus PDFs, Office-Dateien, Scans. Mit Tesseract für Deutsch und Englisch.
SearXNG (:8080) und Firecrawl (:3002)
Meta-Suchmaschine als Websuche-Backend, plus ein Dienst, der gefundene Seiten wirklich ausliest statt sich mit Suchergebnis-Schnipseln zu begnügen. Warum das zusammengehört, steht in Abschnitt 8.
Warum der Agent bewusst NICHT als normales Modell eingetragen ist

Es wäre einfacher gewesen, jede Agenten-Instanz als weitere OpenAI-Verbindung einzutragen. Genau das darf man aber nicht: Dann sähen beide Nutzer denselben Eintrag in der Modellauswahl — und beide würden auf dieselbe Instanz geroutet. Bei einem Agenten mit eigenem Gedächtnis heißt das, dass die eine Person im Gedächtnis der anderen landet.

Die Pipe löst das, weil sie den angemeldeten Benutzer kennt und serverseitig entscheidet. Es ist keine Bequemlichkeitsschicht, sondern die Mandantentrennung des ganzen Aufbaus.

open-webui — die Verdrahtung, gekürzt auf das Wesentliche
environment:
  # --- Sprachmodell: über den Proxy, NICHT direkt auf :8000 ---
  OPENAI_API_BASE_URL: http://host.docker.internal:8011/v1
  OPENAI_API_KEY: dummy
  ENABLE_OLLAMA_API: "false"
  # Die Agenten stehen hier bewusst NICHT. Sie kommen über die Pipe,
  # die pro angemeldetem Benutzer auf :8642 bzw. :8643 routet.

  # --- RAG: Embeddings über Infinity ---
  RAG_EMBEDDING_ENGINE: openai
  RAG_OPENAI_API_BASE_URL: http://host.docker.internal:7997/v1
  RAG_EMBEDDING_MODEL: bge-m3
  ENABLE_RAG_HYBRID_SEARCH: "true"
  RAG_TOP_K: "10"
  RAG_TOP_K_RERANKER: "20"

  # --- Websuche ---
  ENABLE_RAG_WEB_SEARCH: "true"
  RAG_WEB_SEARCH_ENGINE: searxng
  SEARXNG_QUERY_URL: http://host.docker.internal:8080/search?q=<query>

  # --- Sprache rein / raus ---
  AUDIO_STT_ENGINE: openai
  AUDIO_STT_OPENAI_API_BASE_URL: http://host.docker.internal:8003/v1
  AUDIO_TTS_ENGINE: openai
  AUDIO_TTS_OPENAI_API_BASE_URL: http://host.docker.internal:8002/v1

  # --- unverzichtbar, siehe Warnung ---
  ENABLE_PERSISTENT_CONFIG: "False"
Die Architektur in einem Satz

Die Oberfläche ist Terminal, nicht Gehirn. Sie verwaltet Menschen, Dateien und Gesprächsverläufe. Ob dahinter ein nacktes Sprachmodell antwortet oder ein Agent mit einem Dutzend Werkzeugen, entscheidet eine Weiche — und die Weiche kennt den Benutzer.

Was da eigentlich durchsucht wird

Ein RAG-Unterbau ohne Inhalt ist eine leere Bibliothek. Bei mir speisen ihn zwei Quellen, und sie funktionieren bewusst unterschiedlich.

QuelleWas drin istWie sie hereinkommt
DokumenteVerträge, Rechnungen, Korrespondenz, gescannte Papierpost — der normale Bürokram aus der Cloud-Ablagegespiegelt auf den Server, von dort in eine Wissenssammlung der Oberfläche
Wissensspeichermeine eigenen Notizen: Projektstände, Entscheidungen, Messwerte, Fallen — die Textdateien, aus denen auch dieser Artikel entstanden ist zweimal: als Wissenssammlung und als eigenes Werkzeug der Agenten

Weg 1: Die Dokumente

Ein Client spiegelt die Cloud-Ablage auf eine lokale Platte. Entscheidend ist eine einzige Konfigurationszeile:

Die wichtigste Einstellung des ganzen Abschnitts
# ~/.config/onedrive/config
download_only = "true"     # der Server schiebt NIE etwas zurück
sync_list      # nur die Ordner, die wirklich gebraucht werden

Einbahnstraße. Der Server liest, er schreibt nicht. Damit kann kein Fehler in einem Skript, kein verrutschter Pfad und kein experimenteller Agent jemals die eigentliche Ablage beschädigen. Bei einem System, das man abends umbaut, ist das keine Paranoia, sondern die Bedingung dafür, dass man es überhaupt umbauen mag.

Ein kleines Skript vergleicht dann Änderungsdatum und Größe gegen eine Zustandsdatei und lädt nur das Neue in die Wissenssammlung hoch. Dort läuft die Kette weiter: Textextraktion samt Bilderkennung für Scans, danach die Umwandlung in Vektoren. Gelöschte Dateien bleiben bewusst stehen — ein Sync-Fehler soll Wissen nicht vernichten können. Aufräumen ist Handarbeit, und das ist Absicht.

Weg 2: Der eigene Wissensspeicher

Interessanter ist die zweite Quelle. Meine Notizen liegen als schlichte Textdateien in einem Verzeichnis — kein Wiki, keine Datenbank, kein Dienst, der sie einsperrt. Der Grund ist Erfahrung: Dateien überleben Werkzeuge. Jede Notizsoftware, in die ich in zwanzig Jahren Wissen gekippt habe, ist irgendwann verschwunden oder unbezahlbar geworden. Textdateien nicht.

Aus diesem Verzeichnis führen drei Wege in die Maschine:

  1. Als Wissenssammlung in der Oberfläche, per Sync-Skript wie die Dokumente. Für den normalen Chat.
  2. Als eigenes Werkzeug der Agenten — das Verzeichnis ist ihnen nur lesend eingehängt, und sie durchsuchen es hybrid: Volltextsuche und Vektorsuche parallel, das Ergebnis vom Reranker sortiert. Das ist der Weg, den ich im Alltag benutze.
  3. Als kleiner Suchdienst über HTTP, damit auch Werkzeuge außerhalb des Servers nachschlagen können.

Dazu kommt ein Detail, das den Unterschied zwischen Ablage und Gedächtnis ausmacht: Ein stündlicher Lauf sammelt ein, was die Agenten selbst als merkenswert notiert haben, und legt es in denselben Speicher. Ein täglicher Lauf sucht Dubletten und veraltete Einträge. Das Wissen wächst also mit der Arbeit, statt einmal befüllt zu werden und dann zu verrotten.

Warum zweimal derselbe Inhalt?

Weil die beiden Suchen etwas anderes können. Die Vektorsuche der Oberfläche findet, was ähnlich klingt — gut für „was stand nochmal zu diesem Thema drin". Die hybride Suche findet zusätzlich, was wörtlich übereinstimmt — unverzichtbar, sobald exakte Bezeichner im Spiel sind: ein Dateiname, ein Parameter, eine Fehlermeldung. Für genau diese Fälle scheitert reine Ähnlichkeitssuche zuverlässig, und das sind bei technischer Arbeit die meisten Fälle.

Die Datenschutz-Falle, die man erst bemerkt, wenn es zu spät ist

Eine Wissenssammlung wird in der Oberfläche an ein Modell gebunden. Der naheliegende Weg ist, sie an das Basismodell zu hängen — und genau das ist der Fehler: Dann sieht jeder Nutzer des Servers den Inhalt. Meine Steuerunterlagen im Chatfenster meiner Frau sind kein theoretisches Risiko, sondern zwei Klicks entfernt.

Richtig ist eine Zwischenschicht: ein privates, abgeleitetes Modell pro Person, an das die persönlichen Sammlungen gebunden werden — und das über eine explizite Freigabe nur dieser Person sichtbar ist. Ohne diese Freigabe sieht es übrigens niemand außer dem Administrator, was beim ersten Mal wie ein Fehler aussieht. Es ist keiner.

Dasselbe Prinzip wie bei der Pipe weiter oben: Trennung passiert serverseitig, nicht durch Disziplin beim Klicken.

Fünf Fallen, die mich je einen Abend gekostet haben

1. Konfiguration, die sich nicht ändern lässt. Open-WebUI schreibt Einstellungen einmalig in die Datenbank und ignoriert danach die Umgebungsvariablen. Neue Werte greifen nur mit ENABLE_PERSISTENT_CONFIG=False. Ohne das sucht man den Fehler im falschen File.

2. Der Reranker-Schwellwert. Auf 0.01 stellen, nie höher. Deutsche Texte erzeugen komprimierte Ähnlichkeitswerte; ein „vernünftig" aussehender Schwellwert von 0,5 wirft alle richtigen Treffer weg.

3. Zu wenige Dateihandles. Der Docker-Standard von 1024 reicht nicht. Beim Indizieren größerer Dokumentenmengen mit OCR bricht alles mit „Too many open files" ab — und liefert dann allen Nutzern 500er. ulimits: nofile: 65536 setzen.

4. Tika macht ohne Konfiguration kein OCR. Der Standard nimmt an, ein PDF mit Text-Layer brauche keine Bilderkennung. Gescannte Dokumente mit einem winzigen Text-Layer liefern dann Müll. In der tika-config.xml die Strategie OCR_AND_TEXT_EXTRACTION setzen.

5. Der Datei-Upload ist asynchron. Wer eine Datei hochlädt und sie sofort danach der Wissenssammlung hinzufügt, bekommt einen Fehler „Inhalt leer" — die Textextraktion läuft da noch. Die Datei bleibt dann verwaist liegen und wird bei künftigen Läufen stillschweigend übersprungen, weil sie ja „schon da" ist. Man muss auf den Status completed warten, bevor man verknüpft.


07Stufe 4: Bild, Video und Sprache

427 GB Modelle, 24 GB Karte. Wie Bild, Video, Ton und Sprache sich einen Grafikspeicher teilen.

Stufe 4 · Multimodal

Karte 2 trägt drei Dienste gleichzeitig — Generierung, Embeddings, Sprachausgabe. Das geht nur, weil sie sich den Speicher vernünftig teilen, und das ist eine Entscheidung, keine Selbstverständlichkeit.

Die Generierungs-Werkbank: ComfyUI

Hier läuft nicht „ein Bildmodell", sondern eine Bibliothek. Auf der SSD liegen 427 GB Modelle für Bild, Video und Ton — und sie teilen sich eine Karte mit 24 GB.

WasModelleGröße
BildFLUX.1-dev (Standard), FLUX.1-schnell (4 Schritte), FLUX.1 Kontext (Bildbearbeitung per Anweisung)6–12 GB
Krea2 (turbo und raw), Qwen-Image (stark bei Text im Bild), Z-Image Turbo, SDXL-Lightning6–14 GB
VideoLTX-Video 13B distilled — der schnelle Weg15 GB
Wan 2.2: 5B als Einstieg, 14B als Text→Video und Bild→Video3,6–15 GB
TonACE-Step (Musik mit Gesang), Stable Audio 3 (Sound-Design, Foley, Instrumentales)9–10 GB

Dazu Text-Encoder und VAEs, die sich mehrere Modelle teilen — deshalb ist die Bibliothek kleiner als die Summe ihrer Teile. Ein einzelner Encoder wie umt5-xxl wiegt schon 6,7 GB und wird von allen Video-Modellen benutzt.

Die Rechnung geht offensichtlich nicht auf, und genau daraus folgt die wichtigste Betriebsentscheidung dieses Abschnitts.

Laden, generieren, entladen

ComfyUI läuft hier bewusst ohne --highvram. Modelle werden bei Bedarf geladen und unter Druck wieder ausgelagert; nach jeder Generierung über die Automatisierung folgt ein POST /free. Der Preis sind 40–60 Sekunden für das erste Bild nach einer Pause statt 30 warm.

Dafür überlebt der Wechsel zwischen einem Bild- und einem Video-Modell — und die Nachbarn auf der Karte, Embeddings und Sprachausgabe, überleben ihn auch.

/data/docker/comfyui/docker-compose.yml — Kernstück
services:
  comfyui:
    image: comfyui-ampere:1.0
    restart: unless-stopped
    ports: ["8188:8188"]
    volumes:
      - /opt/models/comfyui:/opt/ComfyUI/models:rw
      - /opt/models/comfyui/output:/opt/ComfyUI/output:rw
      # custom_nodes gemountet — sonst sind Erweiterungen nach jedem
      # Rebuild wieder weg. Der Node-Code überlebt jetzt, die pip-Deps nicht.
      - /opt/models/comfyui/custom_nodes:/opt/ComfyUI/custom_nodes:rw
    deploy:
      resources: {reservations: {devices: [{driver: nvidia,
        device_ids: ["2"], capabilities: [gpu]}]}}
    # KEIN --highvram: load-on-demand statt Pinning, siehe oben
    command: ["python3", "main.py", "--listen", "0.0.0.0", "--port", "8188"]

Dieser Container generiert seit dem 6. Juli ohne einen einzigen Neustart.

Vier Dinge, die in keiner Anleitung stehen

GGUF, nicht die anderen 4-bit-Formate
Für die großen Bild- und Video-Modelle ist GGUF das Format, das die Werkzeuge tatsächlich lesen. Mein erster Versuch mit einem bibliothekseigenen 4-bit-Format scheiterte an einem Tensor-Layout, das zwar korrekt war, aber eben nicht das, was ComfyUI erwartet. Vier Stunden für eine Erkenntnis, die in einem Satz passt: GGUF ist hier der Standard, alles andere ist ein Sonderweg.
Wan 2.2 lädt zwei Modelle pro Video
Die 14B-Variante besteht aus einem High-Noise- und einem Low-Noise-Experten — der eine legt die grobe Bewegung an, der andere zeichnet die Details. Beide sind eigene Dateien, und man braucht beide. Das ist der Grund, warum bei der Quantisierungsstufe gerechnet werden muss: Es passt immer nur ein Experte gleichzeitig resident in die Karte. Wer die Dateiliste überfliegt und nur eine der beiden Hälften lädt, bekommt keine Fehlermeldung, sondern schlechte Videos.
Speed-LoRAs machen den Unterschied zwischen Demo und Werkzeug
Ein 14B-Videomodell mit 20 Durchläufen ist auf einer 3090 eine Kaffeepause. Mit den passenden Beschleuniger-LoRAs sind es vier Durchläufe — dieselbe Karte, dieselbe Auflösung. Dasselbe gilt für Qwen-Image (8 statt 20). Diese kleinen Dateien entscheiden darüber, ob man das Modell benutzt oder nur einmal ausprobiert.
Bei Speichermangel den Text-Encoder auf die CPU schicken
Die Video-Gewichte allein liegen bei 14–20 GB. Wird es eng, setzt man im Lade-Knoten für den Text-Encoder schlicht device=cpu. Der Encoder läuft einmal am Anfang und ist danach fertig — er hat nichts davon, im Grafikspeicher zu wohnen, während das eigentliche Modell dort um Platz kämpft.
Die Falle, die zweimal zuschlägt

ComfyUI-Erweiterungen bestehen aus zwei Teilen: dem Node-Code und seinen Python-Abhängigkeiten. Der Ordner custom_nodes ist bei mir gemountet, der Code überlebt also einen Rebuild — die nachinstallierten Abhängigkeiten aber nicht, die liegen im Image.

Ergebnis: Nach einem Rebuild sind die Erweiterungen scheinbar da und funktionieren trotzdem nicht. Die dauerhafte Lösung ist, jede Erweiterung, die man wirklich braucht, ins Dockerfile aufzunehmen. Was im laufenden Container per Hand nachinstalliert wurde, ist geliehen, nicht besessen.

Sprachausgabe: XTTS-v2 mit geklonter Stimme

TTS läuft über openedai-speech mit XTTS-v2 auf Karte 2. Ein Detail, das den Unterschied macht: ein eigenes Image mit DeepSpeed. Das beschleunigt den autoregressiven Teil um Faktor ~1,75 — 464 Zeichen fallen von 17 auf 10 Sekunden, also etwa 3,3-fache Echtzeit.

Warum Stimmen stottern — und warum mehr Strom nicht hilft

XTTS erzeugt Audio Token für Token. Bei Aussetzern im Vorlesen ist die Ursache fast immer Overhead pro Token, nicht fehlende Rechenleistung. Ich habe das Power-Limit hochgesetzt: keine Änderung. Was hilft, ist die Ausgabe absatzweise zu zerlegen (AUDIO_TTS_SPLIT_ON=paragraphs), damit die Wiedergabe früher beginnt.

Spracherkennung: Whisper — bewusst auf der CPU

Das klingt nach einem Fehler und ist eine Optimierung. Im Sprachchat lief Whisper parallel zu XTTS auf derselben Karte. Beide rissen sich um die GPU, und das Vorlesen hakte — das, was der Nutzer hört. Die Erkennung ist stoßweise und verträgt die CPU problemlos; die Ausgabe braucht die Karte für sich.

speaches — Spracherkennung, CPU
environment:
  WHISPER__MODEL: Systran/faster-whisper-small
  WHISPER__COMPUTE_TYPE: int8      # schnellster CPU-Modus
  WHISPER__DEVICE: cpu
  # -1 = nie entladen. Mit dem 300s-Standard war JEDE Sprachnachricht
  # ein Kaltstart: +13,6s nur fürs Modell-Laden — genug, um in
  # jedes vernünftige Timeout zu laufen.
  WHISPER__TTL: "-1"
Das Muster

Auf einer geteilten Karte gewinnt nicht der Dienst, der am meisten Rechenleistung braucht, sondern der, dessen Verzögerung ein Mensch bemerkt. Alles andere darf auf die CPU oder warten.


08Stufe 5: Agenten

Der Punkt, an dem aus einem Chatfenster ein Mitarbeiter wird — und zwei Instanzen, die sich nichts erzählen.

Stufe 5 · Agentenschicht

Auf Zuse laufen zwei Agenten-Instanzen: eine für mich, eine für meine Frau. Getrennte Prozesse, getrennte Zustände, getrennte Werkzeuge, getrennte Telegram-Anbindungen. Das ist keine Spielerei, sondern eine Datenschutz-Entscheidung: Ein Agent mit Gedächtnis, den sich zwei Menschen teilen, ist ein Leck. Wie die Anfrage überhaupt bei der richtigen Instanz landet, steht in Abschnitt 6 — es entscheidet die Pipe anhand des angemeldeten Benutzers.

Was diese Schicht ausmacht, ist nicht das Modell — das ist dasselbe wie im Chat. Es sind die Werkzeuge. Und die sind pro Instanz unterschiedlich, weil zwei Menschen unterschiedlich arbeiten:

WerkzeugAgent A (ich)Agent B (sie)Was es tut
Recherche✓✓Suche → Volltext holen → neu sortieren, in einem Aufruf
Bildgenerierung✓✓schickt einen Auftrag an die Bild-Engine auf Karte 2
Dateizustellung✓✓legt PDF/ZIP hin und gibt einen klickbaren Link zurück
Grammatikprüfung✓✓auf Abruf gegen den Sprachprüf-Dienst, kein Automatismus
Wissensbasis-Suche✓—hybride Suche über den gemeinsamen Wissensspeicher
Kapitel-Lader—✓lädt für ein Buchprojekt nur das gerade nötige Kapitel

Der Kapitel-Lader ist ein gutes Beispiel für ein Werkzeug, das nur für eine Person Sinn ergibt — und für den Grund, warum getrennte Instanzen mehr sind als getrennte Zugangsdaten.

Der Kapitel-Lader verdient eine Erklärung, weil er ein allgemeines Problem löst. Ein Buchprojekt mit zwölf Kapiteln passt zwar in 256.000 Token, aber alles gleichzeitig zu laden macht jede Antwort langsam und teuer. Statt das ganze Material in den Systemprompt zu kippen, lädt ein winziges Werkzeug auf Zuruf genau das an, was gebraucht wird. Kontextfenster sind ein Budget, kein Lagerraum.

Vier Lektionen aus einem Jahr Agentenbetrieb

Recherche gehört in ein Werkzeug, nicht in drei. Erst zerlegte ich das in „suchen", „Seite holen", „bewerten" — das Modell rief brav die Suche auf und arbeitete dann mit den Ergebnis-Schnipseln weiter, statt die Seiten wirklich zu lesen. Als Suche, Extraktion und Reranking ein Werkzeug wurden, wurde die Qualität schlagartig besser.

Werkzeuge als Code, nicht als Anleitung. Fähigkeiten, die als Beschreibung im Prompt stehen („du kannst dieses Skript aufrufen"), werden unzuverlässig genutzt. Als registrierte Werkzeuge mit Signatur werden sie zuverlässig genutzt. Derselbe Inhalt, anderer Ort.

Ein Modell, das Werkzeuge ignoriert, ist meist falsch eingestellt. Als meine Plugins „plötzlich nicht mehr taten", lag es nicht an den Plugins: Ein aus einer Prosa-Empfehlung übernommener presence_penalty von 1,5 sorgte dafür, dass das Modell nie wieder einen Funktionsaufruf produzierte. Bei Code und Werkzeugen gehört der Wert auf 0,0.

Wenn etwas hängt, den echten Request mitschneiden. Ich habe einmal 30 Minuten auf eine Antwort gewartet, die nie kam, und in den falschen Logs gesucht. Die Ursache war ein einzelnes fehlendes Feld im Request-Body auf genau einem von zwei Codepfaden. Danach: 31 Sekunden.

Der Ratschlag, der aus alledem folgt, ist unspektakulär: Agenten scheitern selten am Modell und fast immer an der Verdrahtung. Wer den tatsächlich abgeschickten Request sehen kann, findet den Fehler in Minuten statt in Abenden.


09Stufe 6: Das Dashboard

Grün auf schwarz, Zeilenraster, Magic-Eye-Röhren — und darunter eine Architektur-Entscheidung, die ernster ist, als es aussieht.

Stufe 6 · Beobachtung

Irgendwann läuft genug, dass man nicht mehr weiß, was läuft. Die übliche Antwort wäre Prometheus, Grafana, Exporter, Alertmanager — vier weitere Dienste, die auch gewartet werden wollen.

Ich habe stattdessen einen einzelnen Container geschrieben: FastAPI plus reines HTML und JavaScript. Kein npm, kein Build-Schritt, keine Observability-Landschaft. Er zeigt CPU pro Sockel, RAM, Temperaturen, GPUs, Netzdurchsatz, Platten, Container, Plattengesundheit und den Zustand der Inferenz-Engines. Und er sieht aus wie ein Terminal von 1983, weil das Spaß macht und weil man auf kontrastreichem Grün-auf-Schwarz tatsächlich schneller sieht, wenn etwas rot ist.

So sieht das aus — das Folgende ist kein Bild, sondern mit dem echten Stylesheet des Dashboards gebaut, gefüllt mit den Werten dieser Maschine im Moment des Schreibens:

root@zuse:~# ./status --all
B.O.F.H. CONTROL
EXCUSE OF THE MOMENT:
> Someone kubectl delete'd the wrong namespace
[ GPU MELT STATUS ]
RTX 3090 #049°C · 31,6 W
VRAM22700 / 24576 MiB
RTX 3090 #141°C · 31,1 W
VRAM22700 / 24576 MiB
RTX 3090 #233°C · 24,0 W
VRAM19972 / 24576 MiB
POWER CAP[ COOL 250W ] [ boost 350W ]
[ HALLUCINATION ENGINES ]
vLLM
qwen3.8-27b
[ UP ]
69.5 t/s
Infinity
bge-m3
[ UP ]
6.2 t/s
llama.cpp
—
[ DOWN ]
—
[ MEAT CPU ]
Sockel 0 — Xeon E5-2643 v345°C
Sockel 1 — Xeon E5-2643 v341°C
LOAD AVG2,25 / 1,88 / 1,80 · 24 Threads
[ VOLATILE STORAGE ]
RAM25,8 / 60,5 GiB — 42,7 %
[ S.M.A.R.T. — DISK HEALTH ]
sdd · SSD root197:0 198:0
sde · SSD modelsCRC 804
sdf · HDD /data197:0 198:0
sdg · HDD /var/lib197:0 198:0
UPTIME8 Tage, 5 Std.
vllmopen-webuiowui-postgres comfyuiinfinityspeaches openedai-speechspeaches-proxytika searxngsearxng-redislanguagetool firecrawl-apifirecrawl-redisfirecrawl-rabbitmq firecrawl-playwrightfirecrawl-postgrescaddy agent-1agent-1-dashboardagent-2 agent-2-dashboardthinkoffshare mosquittoforgejo-runnerbofh-dashboard 27 up · 0 down

Nachbau mit dem Original-Stylesheet, echte Werte vom 28.08.2026, 22:58 Uhr. Die drei Röhren rechts oben sind der Teil, über den ich am häufigsten gefragt werde.

Die eine Entscheidung, aus der alles folgt

Ein Container, der Plattengesundheit ausliest oder GPU-Power-Limits verstellt, bräuchte privilegierten Zugriff auf die Hardware. Ein Dashboard mit Root-Rechten auf den Host ist aber genau das, was man nicht will. Also andersherum:

Der Host sammelt, der Container liest

Lesen: nur beobachtend. Der Container bindet /proc, /sys, den Docker-Socket und den SMART-Schnappschuss read-only ein. Er sieht alles und kann nichts ändern.

Schreiben: über eine Datei. Privilegierte Arbeit läuft auf dem Host. Das Dashboard schreibt nur einen Wunschwert in eine kleine Datei; eine systemd-.path-Unit bemerkt die Änderung und führt die eigentliche Aktion aus. Die einzigen schreibbaren Mounts des Containers sind diese Trigger-Dateien.

Konkret am Beispiel Power-Limit: nvidia-smi -pl ist im Container selbst für root gesperrt („Insufficient Permissions"). Die Brücke sieht so aus:

Datei-Trigger → systemd → GPU. Vier kleine Teile, kein Daemon.
# 1. Der Wunschwert — das Dashboard schreibt hier hinein
/var/lib/zuse-power-cap/desired          # z.B. "250"

# 2. Das Skript auf dem Host, das die Arbeit macht
#    /usr/local/sbin/zuse-power-cap-apply
WATTS=$(cat /var/lib/zuse-power-cap/desired)
[ "$WATTS" -lt 200 ] && WATTS=200
[ "$WATTS" -gt 350 ] && WATTS=350       # kleinstes HW-Limit aller Karten
# Karten über den NAMEN finden, nicht über Indizes — PCI-Nummern wandern
IDX=$(nvidia-smi --query-gpu=index,name --format=csv,noheader \
      | grep '3090' | cut -d, -f1 | paste -sd,)
nvidia-smi -i "$IDX" -pl "$WATTS"

# 3. Die Unit, die es ausführt: nvidia-power-cap.service (oneshot)
# 4. Der Wächter: nvidia-power-cap.path
[Path]
PathChanged=/var/lib/zuse-power-cap/desired

Dasselbe Muster steuert bei mir noch zwei weitere Umschalter im Dashboard: Embeddings zwischen GPU und CPU, Sprachausgabe zwischen GPU und CPU. Ein Klick, eine Datei, eine systemd-Unit, ein docker compose up -d mit einem Override-File. Keine neuen Hintergrunddienste.

Warum ich SMART überhaupt selbst auslese

Weil die übliche Anzeige lügt. smartctl meldet einen Gesamtstatus PASSED, während bereits Sektoren unlesbar sind — die Attribute, auf die es ankommt (197 Current_Pending_Sector und 198 Offline_Uncorrectable), haben einen Schwellwert von null und lösen den Sammelstatus nie aus.

Mir ist im August eine Platte gestorben, deren Gesamtstatus bis zuletzt grün war. Das Dashboard zeigt deshalb die Rohwerte, und ein leerer oder veralteter Zustand wird ausdrücklich als solcher angezeigt statt einfach grün zu bleiben. Ein Check, der nicht fehlschlagen kann, prüft nichts.

Zwei Datenklassen, damit nichts blockiert

Ein Detail, das den Unterschied zwischen „Dashboard" und „hängendem Dashboard" ausmacht:

Warum da Magic-Eye-Röhren blinken

Die schnellste Antwort: weil sie mir gefallen. Die ehrliche Antwort ist ein bisschen länger.

Eine 6E1П ist eine sowjetische Abstimmanzeige-Röhre — dasselbe Bauteil, das in alten Radios zeigte, ob ein Sender sauber getroffen war. Ein grün fluoreszierender Streifen, dessen dunkler Spalt sich schließt, je stärker das Signal wird. Kein Zahlenwert, keine Skala: ein Zustand, den man aus drei Metern Entfernung im Vorbeigehen erfasst.

Genau das brauchte ich für den Token-Durchsatz. Eine Zahl wie „69,5 t/s" muss man lesen und einordnen. Ein sich schließender Spalt sagt sofort: Da arbeitet was. Im Dashboard ist jede Röhre einer Inferenz-Engine zugeordnet; der Spalt schrumpft mit dem Durchsatz, die Kathode unten glimmt orange und flackert leicht, weil eine echte Röhre das auch tut. Es sind ein paar Dutzend Zeilen CSS — Leuchtstreifen, dunkles Band mit weicher Übergangsanimation, Glaskante als Lichtreflex.

Der ganze Zauber — der Spalt ist einfach eine Höhe in Prozent
// Durchsatz → Spaltbreite. Viel Durchsatz = geschlossener Spalt.
function tubeGapPct(tps, maxTps) {
  const ratio = Math.max(0, Math.min(1, tps / maxTps));
  return (1 - ratio) * 100;
}

/* Die Animation macht das CSS — 1,2s weich, damit es atmet statt zu zappeln */
.tube-shadow {
  transition: height 1200ms cubic-bezier(0.4, 0, 0.2, 1);
}
Ein wichtiges Implementierungsdetail

Die Röhren-Elemente werden nicht bei jedem Aktualisierungszyklus neu erzeugt, sondern an Ort und Stelle verändert. Baut man das DOM alle 500 ms neu auf, hat die CSS-Transition nie etwas, worauf sie überblenden könnte — der Spalt springt hart statt sanft zu gleiten. Das ist der Unterschied zwischen „sieht nach Röhre aus" und „sieht nach Fortschrittsbalken aus".

Und weil die Software-Röhren so gut funktionieren, liegen inzwischen drei echte 6E1П hier herum, samt Treibermodulen und Anodenspannungs-Wandler. Der Plan steht: ein Arduino am USB, ein kleiner Dienst auf dem Host, der die GPU-Auslastung über pynvml abfragt — nicht über nvidia-smi, dessen Prozessstart pro Abfrage zu teuer ist — und pro Karte eine Zeile U 73 81 12 über die serielle Schnittstelle schickt. Der Arduino bildet 0–100 % auf eine Steuergitterspannung von 0 bis −10 V ab. Die Nachleuchtdauer des Phosphors liegt bei etwa 50 ms, das reicht für eine flüssige Anzeige bei rund 50 Aktualisierungen pro Sekunde.

Dann steht neben dem offenen Rig eine Reihe grün glimmender Röhren, an denen man sieht, wie ein Sprachmodell denkt. Praktischer Nutzen: überschaubar. Aber es ist genau die Art von Detail, die einen Server zu seinem Server macht — und das ist bei einer Maschine, an der man abends freiwillig weiterbaut, kein Nebenaspekt.


10Betrieb

Strom, Sicherung, Netz — die unspektakulären Dinge, die entscheiden, ob das Ding ein Werkzeug ist oder ein Hobby.

Power-Cap: 250 statt 350 Watt

Alle drei Karten laufen dauerhaft mit einem Limit von 250 W statt der möglichen 350. Der Grund ist nicht Vorsicht, sondern eine Messung: Bei 350 W liefert die Maschine 69,3 Token/s statt 69,5. Bei 16 parallelen Anfragen ist das Ergebnis identisch.

Das ist kein Messfehler, sondern eine direkte Folge des Leitprinzips aus Abschnitt 1: Generieren ist bandbreitengebunden. Mehr Watt beschleunigen Rechenwerke, die ohnehin auf Speicher warten. 100 Watt pro Karte gespart, 300 Watt für die Maschine — für 0,3 % Tempo.

Wo der Power-Cap dann doch etwas bringt

Auf einer Karte ohne Tensor-Parallel sieht es anders aus: dort 39,4 t/s bei 250 W gegen 45,8 t/s bei 350 W, also gut 16 %. Wer mit einer Karte baut, sollte sie laufen lassen. Wer mit zweien aufteilt, kann getrost cappen.

Sicherung: eine Lektion, die weh tat

Die Sicherung läuft nächtlich nach der 3-2-1-Regel — eine Kopie im Haus auf ein zweites Gerät, eine außer Haus, mit Aufbewahrung über 7 Tage, 4 Wochen und 6 Monate, und einer Meldung aufs Telefon, wenn ein Lauf fehlschlägt.

Blacklist statt Whitelist

Ursprünglich sicherte ich eine sorgfältig gepflegte Liste der wichtigen Pfade. Als die Datenplatte starb, war der Ordner mit den geklonten Stimmen nicht dabei. Er stand nicht auf der Liste, weil er angelegt wurde, nachdem die Liste geschrieben war.

Seitdem gilt: alles sichern, Ausnahmen definieren. Und die Zeile „does not exist, skipping" im Sicherungslog ist keine Information, sondern eine Warnung — sie bedeutet, dass sich die Realität unter der Konfiguration weggedreht hat.

Netz und Erreichbarkeit

Der Server hat eine feste LAN-Adresse, mehr braucht es zunächst nicht. Zwei Details, die trotzdem Zeit gekostet haben:


11Messen

Die Zahlen, das Vorgehen — und die sechs Fallen, in die ich beim Messen selbst getreten bin.

Das hier ist der Abschnitt, wegen dem ich den Artikel überhaupt schreibe.

Über lokale KI wird viel behauptet. Behauptungen kosten nichts. Eine Messung kostet einen Abend, aber danach weiß man Bescheid — und zwar auch dann, wenn das Ergebnis unbequem ist. Drei der Ergebnisse unten haben Annahmen von mir kassiert.

Durchsatz über Parallelität

Freigeräumte Maschine, 27B-int4 über zwei Karten, 250 W, kurze Anfragen (~20 Token Prompt, 256 Token Antwort):

GESAMTDURCHSATZ vs. GLEICHZEITIGE ANFRAGEN 1000 800 600 400 200 Token/s 69,5 227 631 848 978 905 ↓ 1 4 16 32 64 128 gleichzeitige Anfragen KV-Cache voll
Abb. 4 — Der Höhepunkt liegt bei 64 parallelen Anfragen. Danach wird es wieder langsamer: Der Zwischenspeicher ist voll, 39 Anfragen warten. Mehr Parallelität ist ab hier schädlich.
parallelgesamt Token/sje AnfrageKV-Cachewartend
169,569,51 %–
4226,756,75 %–
16631,439,518 %–
32848,226,536 %–
64978,215,372 %–
128905,57,1100 %39

KV-Cache-Kapazität laut Startprotokoll: 537.847 Token.

Der eigentliche Engpass ist nicht das Schreiben, sondern das Lesen

Das war das Ergebnis, das meine Intuition am gründlichsten kassiert hat. Von 1.000 auf 200.000 Token Kontext fällt die Schreibrate nur von 65,9 auf 52,3 Token/s — ein Rückgang von 21 %. Die Wartezeit bis zum ersten Token steigt im selben Zeitraum von 0,7 auf 232,6 Sekunden. Faktor 175.

Faustformel für jede Konstellation

Wartezeit ≈ Summe aller Prompt-Token ÷ 1.150

Das Einlesen läuft konstant mit etwa 1.000–1.250 Token/s, unabhängig davon, wie viele Anfragen parallel laufen. Bestätigt: 8 × 65.000 Token = 520.000 → 416 Sekunden gemessen.

Daraus folgt die Erklärung für ein Phänomen, das sonst wie ein Defekt aussieht: „Der Server macht plötzlich 2 Token/s." Wer schreiben will, während im Hintergrund ein fremder Prompt mit 150.000 Token eingelesen wird, bekommt weniger als 1 Token/s. Nicht kaputt — beschäftigt.

Und der eine Hebel, der wirklich alles ändert

Derselbe Prompt mit 151.000 TokenWartezeitCache-Treffer
zum ersten Mal155,2 s0 %
identische Anfrage erneut1,9 s99,5 %
neue Frage am Ende angehängt2,0 s99,5 %
eine Änderung am Anfang155,7 s0 %

Entscheidend ist nicht, wie viel sich ändert, sondern wo. Ab der ersten Abweichung muss alles dahinter neu gelesen werden.

Die praktische Konsequenz — und ein Selbst-Tritt

Steht am Anfang eines System-Prompts ein Zeitstempel, eine Sitzungs-ID oder ein Zufallswert, entwertet das den kompletten Cache dahinter. Bei 150.000 Token Kontext kostet das jede einzelne Anfrage zweieinhalb Minuten — für eine Zeitangabe, die niemand braucht.

Wer über langsame lange Kontexte klagt, sollte nicht über Quantisierung oder Stromlimits reden, sondern zuerst den Anfang seines Prompts ansehen.

Sechs Fallen beim Selbstmessen

In jede einzelne bin ich getreten. Wer eigene Zahlen erheben will, spart sich damit einen Abend:

  1. Die Maschine wirklich freiräumen. Die offensichtlichen Container zu stoppen reicht nicht — bei mir sprach ein Client von einem anderen Rechner den Server direkt an und tauchte in keiner Container-Liste auf. Vor jeder Stufe auf „null laufende Anfragen" warten und währenddessen auf Fremdlast prüfen.
  2. Nicht selbst Zeitfenster ausrechnen. Mein „gemeinsames Zeitfenster vom letzten Anfangs- bis zum letzten Endzeitpunkt" ergab 418 Token/s, wo real 2,5 waren. Stattdessen die Zähler der Engine (vllm:generation_tokens_total, vllm:prompt_tokens_total) vor und nach der Stufe differenzieren.
  3. Kontextlängen mit dem Tokenizer kalibrieren, nicht über Wörter schätzen. Deutsche Wörter liegen bei ~1,77 Token, nicht 1,35 — sonst sind alle Stufen 31 % zu groß.
  4. „Avg prompt throughput: 0.0" im Protokoll täuscht. Bei stückweisem Einlesen werden die Token erst bei Fertigstellung verbucht, dann als Schub. Der Mittelwert aus den Zählern ist die ehrliche Zahl.
  5. Eine aggregierte Token-Rate ist nicht das Tempo einer Anfrage. Als mein Dashboard 104 t/s anzeigte, waren das zwei parallele Anfragen à 50,9 — also pro Anfrage langsamer als die 69,5 solo. Vor jedem „ist jetzt schneller!" die Zahl der laufenden Anfragen mitlesen und teilen.
  6. Abgebrochene Anfragen laufen weiter. Trennt sich der Client, generiert die Engine bei nicht gestreamten Anfragen munter zu Ende — und belegt dabei die Karte.
Was auf dieser Maschine messbar nichts gebracht hat

CPU-Governor auf performance, NUMA-Pinning der Prozesse, asynchrone Ablaufplanung in der Engine: alle drei null. Die CPU ist hier nicht der Engpass, und auf dieser GPU-Generation gibt es keine Recheneinheiten für die schnelleren Zahlenformate — das eingesetzte 4-bit-Verfahren ist bereits das Maximum. Wer an diesen Schrauben dreht, optimiert sein Gefühl, nicht seine Maschine.


12Das Modell selbst quantisieren

Zwei Stunden auf einer Karte — und die Kiste liefert etwas zurück, statt nur zu verbrauchen.

Der Teil, auf den ich am ehesten stolz bin: Das Modell, das hier läuft, habe ich selbst quantisiert. Auf denselben Karten, auf denen es jetzt arbeitet. Es liegt öffentlich auf Hugging Face und wurde im letzten Monat 1.858 mal heruntergeladen.

Der Anlass war banal: Es erschien eine neue Modellversion, für die es noch kein brauchbares 4-bit-Paket gab. Statt zu warten, habe ich es gebaut — und gleich sauber gegen die alte Version gemessen, denn „neuer" heißt nicht „besser".

Das Rezept

Bau-Setup, reproduzierbar
# Bau-Container aus dem vLLM-Image — bringt passende Torch/Transformers mit.
# Nur die freie Karte zuweisen, die anderen bedienen weiter die Nutzer.
docker run --gpus '"device=2"' -v /opt/models:/opt/models \
  vllm/vllm-openai:latest bash -c "pip install auto-round==0.14.2 && \
  python /opt/models/build_qwen38_int4.py"

# Kern-Parameter von AutoRound:
#   bits=4, group_size=128, sym=True, data_type=int
#   format='auto_round:auto_gptq'
#   nsamples=128, iters=200, seqlen=2048, low_gpu_mem_usage=True

Bauzeit: etwa 1,5 Minuten pro Block, 64 Blöcke — also rund zwei Stunden auf einer einzelnen 3090 bei 66–69 °C und 245 W.

Zwei Hürden, an denen es zuerst scheiterte

1. Das Werkzeug erkannte ein multimodales Modell und sprang in einen Kalibrierpfad, der einen Bild-Prozessor verlangt — den es hier nicht braucht. Lösung war, den Modelltyp zur Laufzeit in die Liste der reinen Textmodelle einzutragen. Ein Einzeiler, nachdem man ihn kennt.

2. Die Maschine hat 60 GB RAM, das unquantisierte Modell 54 GB. Das geht rechnerisch nicht auf. Es funktioniert trotzdem, weil das Laden mit low_cpu_mem_usage=True die Datei mappt statt sie zu lesen: Die Blöcke werden bei Bedarf von der SSD eingelagert, ohne dass die Maschine in den Swap läuft. Als Sicherheitsnetz lag eine Auslagerungsdatei bereit — gebraucht wurde sie nicht.

Und dann messen, bevor man umschaltet

Das neue Paket kam erst in Produktion, nachdem es eine Bedingung erfüllt hatte: mindestens so gut wie das alte. Ergebnis: Programmieraufgaben 13 von 13 (alt: 12 von 13), Mathematik 12 von 12 (alt: höchstens 8 von 12), Tempo identisch, Werkzeugaufrufe und Bildverständnis intakt.

Die wichtigste Lektion des ganzen Projekts

Der erste Durchlauf zeigte einen deutlichen Rückschritt beim Programmieren. Das Modell war unschuldig. Es waren drei Fehler in meinem eigenen Test-Gerüst: eine zu kleine Token-Obergrenze, die längere Antworten abschnitt; eine Zahlenprüfung, die das deutsche Komma falsch entfernte; und ein Vergleich, der mathematische Formatierung nicht auflöste.

Bevor man einem Modell misstraut, prüft man das Messwerkzeug. Ich habe fast ein gutes Modell wegen meines eigenen Bugs verworfen.


13Was nicht funktioniert hat

Der ehrlichste Abschnitt. Vier Dinge, die auf dem Papier gut aussahen und in der Praxis verloren haben.

Bauberichte handeln fast immer von Erfolgen. Das ist der Grund, warum sie so schlecht nachbaubar sind. Hier sind die Sackgassen — jede hat mich Tage gekostet, und jede erspart sie jemandem.

1. Spekulatives Dekodieren — 2,5-mal langsamer

Die Idee ist bestechend: Ein kleines Modell rät die nächsten Token, das große prüft nur noch. Gemessen: ~28 Token/s mit, ~70 ohne. Der Grund steht in der Annahmequote — sie lag bei 8–12 %, wo sie 30–50 % sein müsste. Pro Position: 0,17 / 0,11 / 0,06. Das bedeutet dreifache Arbeit für minimalen Gewinn.

2. Ein separates kleines Entwurfsmodell — unmöglich

Der klassische Weg scheitert hier grundsätzlich: Die Wortschätze passen nicht zusammen (248.044 gegen 151.643 Einträge), identischer Text ergibt völlig andere Token-Nummern.

Der Zwei-Minuten-Test, der Tage spart

Vor jedem Versuch mit spekulativem Dekodieren prüfen, ob beide Modelle denselben Wortschatz haben und denselben Satz identisch zerlegen. Wenn nicht: sofort abbrechen.

3. Ein Beschleuniger, der im Benchmark gewann und in der Realität verlor

Das lehrreichste Ergebnis. Ein spezialisierter Entwurfs-Mechanismus zeigte im synthetischen Test 2,18-fache Beschleunigung bei 53,6 % Annahmequote. In meinem tatsächlichen Arbeitsalltag:

ArbeitslastDurchsatzgegen ~65 Token/s vorher
Code mit deutschen Kommentaren13–58 t/sschlechter
JavaScript/HTML, 4 parallel17–46 t/sschlechter
kreatives deutsches Schreiben~20 t/s3× schlechter

Warum der Benchmark gelogen hat: Seine Aufgaben waren reines englisches Code- und Mathematik-Material. Meine Realität sind deutsche Kommentare, Hex-Konstanten, Werkzeugaufrufe als JSON und lange Dialoge — alles außerhalb dessen, worauf der Beschleuniger trainiert war. Dazu kam eine erzwungene Verdopplung des Zwischenspeicher-Formats, die bei langen Kontexten den restlichen Gewinn auffraß.

Die Regel, die daraus folgt

Miss deine eigene Arbeitslast, nicht den Benchmark des Anbieters. Ein Testfeld aus englischen Programmieraufgaben sagt nichts über einen Arbeitstag mit deutschen Texten und Werkzeugaufrufen.

4. Ein größeres, moderneres Modell — an der Gleichzeitigkeit gescheitert

Ein 31B-Modell einer anderen Familie sah auf dem Papier besser aus. Im Test brach es bei mehreren Nutzern ein: Der Zwischenspeicher reichte nur für ~155.000 Token gegen 534.000 beim bisherigen Modell, die Gleichzeitigkeits-Reserve lag bei Faktor 1,19 statt 2,04, das Einzeltempo bei 33 statt 65 Token/s. Unter echter Last waren es 2–11 Token/s samt Zeitüberschreitungen — für meine Frau schlicht unbenutzbar.

Das Sparformat für den Zwischenspeicher, das das gerettet hätte, ließ sich bei diesem Modell auf dieser Kartengeneration nicht aktivieren. Zurückgerollt am selben Abend.

Das gemeinsame Muster aller vier

Jede dieser Sackgassen sah in einer Einzelmessung gut aus und verlor unter meiner Last. Ein lokaler Server wird nicht durch das beste Modell gut, sondern durch die Kombination aus Modell, Kontextlänge und Gleichzeitigkeit, die zur tatsächlichen Nutzung passt.


14Die PENG-Frage

Ob Consumer-Karten unter Dauerlast durchbrennen — und was die Zähler sagen.

Bei gebrauchter Hardware kommt immer dieselbe Frage: Hält das? Oder verabschiedet sich so eine Karte unter Dauerlast mit einem Knall und etwas Rauch?

Die Frage ist berechtigt, und sie ist beantwortbar — der Treiber führt darüber Buch. Er zählt in Mikrosekunden mit, wie lange eine Karte je gedrosselt wurde, getrennt nach Ursache:

nvidia-smi -q -d PERFORMANCE — die Zähler dieser Maschine
Clocks Event Reasons
    HW Slowdown                    : Not Active
        HW Thermal Slowdown        : Not Active
        HW Power Brake Slowdown    : Not Active

Clocks Event Reasons Counters
    HW Thermal Slowdown            : 0 us      ← nie. Nicht einmal.
    HW Power Braking               : 0 us      ← nie.
    SW Thermal Slowdown            : 0 us
    SW Power Capping               : 87814201721 us    ← das bin ich selbst (250-W-Limit)

Null Mikrosekunden thermische Drosselung. Der einzige Zähler, der läuft, ist das Software-Limit — also mein eigener, absichtlich gesetzter Power-Cap. Die Karten arbeiten bei 33 bis 49 °C.

Das ist keine Glückssache, sondern das Ergebnis von drei Entscheidungen:

Was die Maschine tatsächlich leistet

Zahlen von jetzt, aus den Zählern der laufenden Instanz:

Laufzeit der aktuellen Modell-Instanz~24 Stunden
Verarbeitete Prompt-Token in dieser Zeit19.734.727
Generierte Token934.014
Abgeschlossene Anfragen4.851
Anfragen mit Fehler0
Bildgenerierung ohne Neustart seit6. Juli
Systemlaufzeit8 Tage
RAM-Verbrauch bei 27 Containern25,8 / 60,5 GB

Wo die Kritik allerdings recht hat

Damit das hier keine Werbebroschüre wird — drei Dinge, die ein lokaler Server nicht leistet:

Und genau der letzte Punkt ist der Grund, warum das hier kein Hobby ist. Ich arbeite für Automotive und Defence. In diesen Bereichen ist Cloud-KI in weiten Teilen tot — nicht wegen der Kosten, sondern weil bestimmte Daten den Standort nicht verlassen dürfen. Die Frage lautet dann nicht mehr „Cloud oder lokal", sondern nur noch „welche Hardware".


15TL;DR

Wer bis hierher gescrollt hat, bekommt die Kurzfassung.

Die elf Sätze

1. Bandbreite schlägt Menge. Eine gebrauchte 3090 mit 24 GB ist schneller als eine Box mit 128 GB langsamem Unified Memory.
2. „Gemeinsamer GPU-Speicher" im Task-Manager ist normaler RAM. Er rettet nichts.
3. Eine gebrauchte Workstation plus eine 3090 kostet ~1.900–2.100 € und trägt bereits ein 27B-Modell mit 64K Kontext.
4. Zwei Netzteile brauchen eine gemeinsame Masse — sonst fließt der Rückstrom über die Massepins von PCIe-Slot und Riser. Ein dickes Erdungskabel, fest verschraubt.
5. Ein Dienst, ein Compose-File, Verbindungen über den Host, Modelle auf SSD, restart: unless-stopped. Das ist das ganze Betriebsgeheimnis.
6. vLLM statt der einfacheren Werkzeuge, sobald mehr als eine Person den Server nutzt.
7. --gpu-memory-utilization auf 0,95, nicht höher. 0,98 killt die Engine im laufenden Betrieb.
8. Auf einer Karte ist --max-num-seqs 4 der Hebel: spart 2,5 GB und damit ~78.000 Token Kontext.
9. Lange Kontexte sind nicht langsam beim Schreiben, sondern beim Lesen. Prefix-Caching macht daraus 155 Sekunden → 1,9.
10. Power-Cap auf 250 W kostet 0,3 % Tempo. Thermische Drosselung: null Mikrosekunden.
11. Miss deine eigene Arbeitslast. Vier gut aussehende Optimierungen haben bei mir verloren, weil ihre Benchmarks nicht meine Realität waren.

Lokale Inferenz ist kein Hexenwerk. Es braucht etwas Bash, eine brauchbare Grafikkarte und die Bereitschaft, Dinge zu messen statt zu vermuten.

Der Rest ist Geduld und ein Notizbuch, in dem die Sackgassen stehen. Meines ist dieser Artikel.

Markus Kremer — Void-Main IT-Consulting, Ostfriesland.
Agentic-AI- und RAG-Systeme, die im Betrieb funktionieren, nicht nur in der Demo.
20+ Jahre Automotive und Embedded.

LocalLLMSovereignAIHomeLab vLLMRAGAutomotive Ostfriesland

Alle Messwerte stammen von dieser Maschine. Wo Zahlen aus Fremdquellen kommen (Gerätepreise, Bandbreitenangaben der Hersteller), ist das im Text vermerkt. Stand: 28. August 2026.