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.
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
- 936 GB/s (RTX 3090, GDDR6X) sind das theoretisch ~55 Komplettdurchläufe pro Sekunde,
- 273 GB/s (Unified-Memory-Boxen, Mac Studio, DGX Spark) nur ~16.
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.
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.
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:
| Posten | Preis | Notiz |
|---|---|---|
| 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.
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.
| Posten | Preis | Notiz |
|---|---|---|
| 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 · HardwareIm 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
- Ein offener Alu-Rahmen (Mining-Rig, ~50 €). Offen ist hier ein Vorteil: freie Konvektion, keine gestaute Wärme.
- Riser-Kabel, keine Riser-Karten. Wichtig: PCIe Gen3 x16 liegt bei mir voll an. Die Riser limitieren die Lanes nicht. Wer bei Inferenz-Problemen zuerst die Riser verdächtigt, sucht an der falschen Stelle.
- Ein eigenes Netzteil für die GPUs (1 kW). Es versorgt alle drei Karten; das Workstation-Netzteil behält zwei Xeons, RAM und die Platten. Diese Trennung ist der Grund, warum es hier nie Lastspitzen-Probleme gab. Die beiden Netzteile werden über einen Add2PSU-Adapter (oder eine Relaisbrücke am PS_ON-Pin) gemeinsam geschaltet, damit sie zusammen anlaufen. Und sie brauchen eine gemeinsame Masse — siehe den Kasten direkt darunter, das ist der wichtigste Absatz dieses Abschnitts.
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.
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:
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 & ContainerAb 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.
# 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.
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.
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.
/opt/models/<dienst>/. Ein Modell-Cache auf einer Festplatte ist ein Fehler, der sich
bei jedem Containerstart rächt. Ich habe ihn gemacht, einmal.
restart: unless-stopped
Damit kommt nach einem Reboot alles von allein hoch. Mit einer Bedingung, die niemand erwartet — siehe gleich unten.
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 · InferenzDas 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.
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.
--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.
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.
| Lauf | Konfiguration | Gewichte | CUDA-Graphs | KV | Token |
|---|---|---|---|---|---|
| A | naiv: util 0.95, Defaults | 17,45 GiB | — | — | OOM |
| B | util 0.97, max-num-seqs 4 | 17,45 | 0,48 | 2,95 | 83.285 |
| C | wie B, aber seqs 2 | 17,45 | 0,43 | 2,97 | 83.285 |
| D | wie B, Vision aus | 16,59 | 0,48 | 3,29 | 92.842 |
| E | final: max-model-len 81920 | 17,45 | 0,48 | 2,95 | 84.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 & RAGEin 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:
- 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.
- 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.
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.
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.
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 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.
| Quelle | Was drin ist | Wie sie hereinkommt |
|---|---|---|
| Dokumente | Verträge, Rechnungen, Korrespondenz, gescannte Papierpost — der normale Bürokram aus der Cloud-Ablage | gespiegelt auf den Server, von dort in eine Wissenssammlung der Oberfläche |
| Wissensspeicher | meine 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:
# ~/.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:
- Als Wissenssammlung in der Oberfläche, per Sync-Skript wie die Dokumente. Für den normalen Chat.
- 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.
- 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.
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.
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.
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 · MultimodalKarte 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.
| Was | Modelle | Größe |
|---|---|---|
| Bild | FLUX.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-Lightning | 6–14 GB | |
| Video | LTX-Video 13B distilled — der schnelle Weg | 15 GB |
| Wan 2.2: 5B als Einstieg, 14B als Text→Video und Bild→Video | 3,6–15 GB | |
| Ton | ACE-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.
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.
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.
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.
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.
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"
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 · AgentenschichtAuf 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:
| Werkzeug | Agent 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.
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 · BeobachtungIrgendwann 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:
> Someone kubectl delete'd the wrong namespace
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:
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:
# 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.
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:
- Billig und lokal — CPU, RAM, GPU, Netz, Platten kommen bei jedem Abruf frisch aus
/proc,/sysundnvidia-smi, parallel abgefragt. - Langsam oder entfernt — Inferenz-Engines, Docker-Statistiken und SMART werden im Hintergrund gepollt und aus einem Cache bedient. Eine hängende Engine darf die CPU-Anzeige nicht ausbremsen; bei einem Fehler bleibt einfach der letzte gute Wert stehen.
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.
// 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); }
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.
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.
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:
- Selbstsignierte Zertifikate über einen Reverse-Proxy sind nötig, sobald der Browser Mikrofonzugriff erlauben soll — über reines HTTP verweigert er das. Falle dabei: Ändert sich die IP, passt der Zertifikatsname nicht mehr, und Bilder in der Oberfläche brechen. Und ein Konfigurations-Reload liest geänderte Zertifikatsdateien nicht neu; der Proxy-Container muss wirklich neu gestartet werden.
- Veröffentlichte Docker-Ports umgehen die Firewall-Regeln in
INPUT. Sie kommen per NAT über dieFORWARD-Kette an. Wer den Zugriff einschränken will, filtert inDOCKER-USER— und zwar auf den Container-Port, nicht den veröffentlichten. Das ist eine der wenigen Stellen, an denen man sich in falscher Sicherheit wiegen kann.
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):
| parallel | gesamt Token/s | je Anfrage | KV-Cache | wartend |
|---|---|---|---|---|
| 1 | 69,5 | 69,5 | 1 % | – |
| 4 | 226,7 | 56,7 | 5 % | – |
| 16 | 631,4 | 39,5 | 18 % | – |
| 32 | 848,2 | 26,5 | 36 % | – |
| 64 | 978,2 | 15,3 | 72 % | – |
| 128 | 905,5 | 7,1 | 100 % | 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.
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 Token | Wartezeit | Cache-Treffer |
|---|---|---|
| zum ersten Mal | 155,2 s | 0 % |
| identische Anfrage erneut | 1,9 s | 99,5 % |
| neue Frage am Ende angehängt | 2,0 s | 99,5 % |
| eine Änderung am Anfang | 155,7 s | 0 % |
Entscheidend ist nicht, wie viel sich ändert, sondern wo. Ab der ersten Abweichung muss alles dahinter neu gelesen werden.
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:
- 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.
- 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. - 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ß.
- „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.
- 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.
- Abgebrochene Anfragen laufen weiter. Trennt sich der Client, generiert die Engine bei nicht gestreamten Anfragen munter zu Ende — und belegt dabei die Karte.
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-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.
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.
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.
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:
| Arbeitslast | Durchsatz | gegen ~65 Token/s vorher |
|---|---|---|
| Code mit deutschen Kommentaren | 13–58 t/s | schlechter |
| JavaScript/HTML, 4 parallel | 17–46 t/s | schlechter |
| kreatives deutsches Schreiben | ~20 t/s | 3× 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ß.
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.
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:
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:
- Offenes Rig statt geschlossenem Gehäuse. Kein Wärmestau, freie Konvektion.
- 250 W statt 350 W. Kostet 0,3 % Tempo (Abschnitt 10) und nimmt viel Wärme heraus.
- Ein eigenes Netzteil für die Karten. Keine Lastspitzen, die sich das Board mit zwei Xeons und vier Platten teilen muss.
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 Zeit | 19.734.727 |
| Generierte Token | 934.014 |
| Abgeschlossene Anfragen | 4.851 |
| Anfragen mit Fehler | 0 |
| Bildgenerierung ohne Neustart seit | 6. Juli |
| Systemlaufzeit | 8 Tage |
| RAM-Verbrauch bei 27 Containern | 25,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:
- Ein 27B-Modell in 4 bit ist kein Frontier-Modell. Es erreicht nicht die Werte, die ein Anbieter für seine großen Modelle bei voller Präzision veröffentlicht. Wer das behauptet, verkauft etwas. Was es leistet, ist: gut genug für die allermeiste tägliche Arbeit, bei voller Datenhoheit.
- Auf 8 GB VRAM geht das alles nicht. Da fängt dieser Artikel an, und die ehrliche Antwort war Hardware kaufen, nicht klüger konfigurieren.
- Eine einzelne Anfrage ist langsamer als bei einem Cloud-Anbieter. 69,5 Token/s sind flüssig, aber kein Rekord. Der Vorteil liegt woanders: 64 gleichzeitige Anfragen, unbegrenzte Nutzung ohne Abrechnung pro Token, und Daten, die den Standort nicht verlassen.
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.
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.