LLama.cpp mit AMD Radeon 560: Eine technische Reise zu 96K Kontext bei 16 Tokens pro Sekunde

Einleitung

Was kann man mit einer alten AMD Radeon 560 (4GB VRAM) im Jahr 2026 noch anfangen? Diese Frage stellte ich mir und begann ein Experiment: Wie weit lässt sich ein modernes KI-Sprachmodell auf dieser bescheidenen Hardware pushen? Das Ergebnis übertraf meine Erwartungen bei weitem.

Nach zahlreichen Iterationen, Fehlschlägen und Optimierungen laufe ich nun Microsofts Phi-4-mini-Modell (3,8B Parameter) mit 96.000 Token Kontext bei 16,4 Tokens pro Sekunde auf einer GPU, die 2017 für unter 100 Euro zu haben war.

Dieser Blogpost dokumentiert die gesamte Reise: von den ersten Treiberproblemen über die erfolgreiche Kompilierung von llama.cpp mit Vulkan-Support bis hin zur finalen Integration eines Agent-Frameworks für persistente Speicherung.

Die Hardware-Grundlagen

AMD Radeon RX 560 (Polaris 11)

• 4 GB GDDR5 VRAM
• 112 GB/s Speicherbandbreite
• Vulkan 1.4 Support
• Treiber: RADV (Open-Source) oder AMDVLK (proprietär)

Die Polaris-Architektur gilt offiziell als nicht mehr von ROCm unterstützt. Dies schloss eine Nutzung der AMD-eigenen Compute-Stack aus. Der einzige realistische Weg war Vulkan.

Phase 1: Treiber und Berechtigungen

Das erste Hindernis war typisch für Linux-Neulinge auf diesem Gebiet: Fehlende Berechtigungen für den Zugriff auf /dev/dri/renderD128. Die Lösung bestand darin, den Benutzer den Gruppen render und video hinzuzufügen:

sudo usermod -aG render,video benutzername

Nach einem vollständigen Logout war die GPU für Vulkan sichtbar.

Die Installation der notwendigen Pakete umfasste:

sudo apt install mesa-vulkan-drivers vulkan-tools libvulkan-dev spirv-headers glslc

Phase 2: Kompilierung von llama.cpp mit Vulkan

Der nächste Schritt war die Kompilierung einer speziellen Version von llama.cpp mit Vulkan-Unterstützung. Die Wahl fiel auf das TurboQuant-Fork, das verbesserte KV-Cache-Kompression für lange Kontexte bietet.

git clone https://github.com/TheTom/llama-cpp-turboquant
cd llama-cpp-turboquant
mkdir build && cd build
cmake .. -DGGML_VULKAN=ON -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)

Während der Kompilierung traten einige Abhängigkeitsprobleme auf: CMake fehlte zunächst, dann OpenSSL (nicht benötigt, ignorierbar) und schließlich SPIRV-Headers. Alle konnten über apt installiert werden.

Phase 3: Model-Auswahl und Download

Die Wahl fiel auf Microsofts Phi-4-mini mit 3,8 Billionen Parametern. Dieses Modell überzeugt durch:

• 83,7 Prozent auf ARC-C (Reasoning-Benchmark)
• 88,6 Prozent auf GSM8K (Mathe-Reasoning)
• Native 128K Kontext (durch Kompression auf 96K nutzbar)
• Q4_K_M Quantisierung bei 2,5 GB Dateigröße

Der Download von Hugging Face erforderte Authentifizierung:

export PATH="$HOME/.local/bin:$PATH"
hf auth login
hf download bartowski/microsoft_Phi-4-mini-instruct-GGUF
--include "microsoft_Phi-4-mini-instruct-Q4_K_M.gguf"
--local-dir ./

Alternativ funktionierte auch wget mit Token:

wget --header="Authorization: Bearer $(cat ~/.cache/huggingface/token)"
https://huggingface.co/bartowski/microsoft_Phi-4-mini-instruct-GGUF/resolve/main/microsoft_Phi-4-mini-instruct-Q4_K_M.gguf
-O microsoft_Phi-4-mini-instruct-Q4_K_M.gguf

Phase 4: Optimierung der Startparameter

Die größte Herausforderung bestand darin, die richtige Balance zwischen Kontextlänge und Stabilität zu finden. Folgende Parameter erwiesen sich als entscheidend:

--ctx-size: Die Kontextlänge in Token
--cache-type-k q8_0: KV-Cache-Kompression für Keys (8-Bit)
--cache-type-v turbo4: Aggressive Kompression für Values
-ngl: Anzahl der auf GPU ausgelagerten Layer
-fa on: Flash Attention (falls unterstützt)
-co on: Farbige Konsolenausgabe
-cnv: Chat-Modus mit Konversationsverlauf

Die Testergebnisse im Überblick:

Kontext	Layer (ngl)	Speed (t/s)	Status
4K	30	19,1	Stabil
32K	30	19,0	Stabil
96K	28	16,4	Stabil
128K	28	-	Absturz durch VRAM-Überlauf

Der endgültige Arbeitsbefehl:

./bin/llama-cli -m microsoft_Phi-4-mini-instruct-Q4_K_M.gguf
--ctx-size 98304
--cache-type-k q8_0
--cache-type-v turbo4
-ngl 28
-co on
-cnv

Phase 5: Integration mit Hermes Agent

Für die praktische Nutzung mit persistenter Speicherung über mehrere Sitzungen hinweg wurde Hermes Agent installiert. Dieses Framework bietet:

• Pluggable Memory Provider für cross-session Kontext
• Automatische Komprimierung bei 80 Prozent Kontextauslastung
• Asynchrone Speicherung ohne Antwortzeitverzögerung

Die Server-Instanz von llama.cpp wird im Hintergrund gestartet:

./bin/llama-server -m microsoft_Phi-4-mini-instruct-Q4_K_M.gguf
--host 127.0.0.1
--port 8080
--ctx-size 98304
--cache-type-k q8_0
--cache-type-v turbo4
-ngl 28

Die Konfiguration von Hermes erfolgt über:

hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes memory setup

Als Memory Provider wurde Honcho gewählt, das eine dreischichtige Speicherarchitektur implementiert: Session Memory (aktueller Chat), User Profile (benutzerspezifische Präferenzen) und Domain Knowledge Base (langfristige Fakten).

Technische Erkenntnisse

1. VRAM-Limitierung: Die 4 GB der Radeon 560 sind das absolute Minimum für sinnvolle LLM-Nutzung. Die Kombination aus 2,5 GB Modellgewicht und KV-Cache für 96K Kontext nutzt die Karte nahezu vollständig aus (90-95 Prozent Auslastung in radeontop).
2. Speicherbandbreite als Flaschenhals: Die Polaris-Architektur mit GDDR5 erreicht nur 112 GB/s. Moderne GPUs liegen bei 360-500 GB/s. Die erreichten 16-19 Tokens pro Sekunde sind daher ein respektables Ergebnis.
3. TurboQuant-Kompression ist entscheidend: Ohne --cache-type-v turbo4 wäre selbst 32K Kontext auf 4GB kaum möglich gewesen. Die aggressive Kompression ermöglicht erst die Nutzung von 96K.
4. Treiberwahl: RADV (Open-Source) funktionierte nach korrekter Berechtigung zuverlässig. AMDVLK wäre eine Alternative, falls spezifische Probleme auftreten.
5. Phi-4-mini vs. größere Modelle: Ein 7B-Modell wie Falcon H1R erreichte auf gleicher Hardware nur 4 Tokens pro Sekunde. Das kleinere, aber effizientere Phi-4-mini ist der klare Gewinner für limitierte GPUs.

Praktische Anwendung

Mit der finalen Konfiguration lassen sich folgende Anwendungen realisieren:

• Technische Dokumentation: Die 96K Kontext umfassen etwa 72.000 Wörter, genug für ein komplettes Fachbuchkapitel.
• Langzeit-Chats: Bei typischen 500-1000 Token pro Nachricht sind 100-200 Austausche möglich, bevor der Kontext gefüllt ist.
• Code-Analyse: Ganze Codebasen können in den Kontext geladen und analysiert werden.
• Persistente Agenten: Durch Hermes und Honcho bleibt das Gespräch über Sitzungsgrenzen hinweg erhalten.

Fehler, die vermieden werden können

Aus meiner Erfahrung die häufigsten Stolpersteine:

• Falsche Gruppenmitgliedschaft: Nach usermod ist ein vollständiger Logout notwendig, nicht nur ein neues Terminal.
• Vergessene PATH-Erweiterung: Die hf-CLI landete in ~/.local/bin, was nicht im Standard-PATH enthalten war.
• Zu aggressive Erwartungen: 128K Kontext sind auf 4GB nicht erreichbar. 96K sind das realistische Maximum.
• Falsche Flags: Sowohl --fa als auch --color erwarten Werte (on/off/auto) und funktionieren nicht als reine Schalter.

Fazit

Die Radeon 560 ist keine KI-Workstation, aber mit den richtigen Optimierungen ein vollständig nutzbares System für moderne Sprachmodelle. Die Kombination aus:

• Phi-4-mini als effizientem Modell
• TurboQuant-Kompression für den KV-Cache
• Hermes Agent für persistente Speicherung

ermöglicht einen flüssigen, intelligenten Assistenten auf Hardware, die viele längst als veraltet betrachten würden.

Die erreichten 16 Tokens pro Sekunde bei 96K Kontext sind subjektiv reaktionsschnell. Eine Antwort erscheint innerhalb weniger Sekunden, auch bei komplexen Abfragen. Für alltägliche Aufgaben wie Textgenerierung, Codeanalyse oder Recherche ist dies vollkommen ausreichend.

Die Zukunft wird zeigen, ob weitere Optimierungen möglich sind. Die grundlegende Erkenntnis bleibt: Effiziente Architektur schlägt rohe Rechenleistung. Phi-4-mini beweist, dass ein gut designtes 3,8B-Modell ein älteres 7B-Modell nicht nur einholt, sondern übertrifft.

Wer eine ähnliche Hardware besitzt und mit KI experimentieren möchte: Die Hürden sind überwindbar, das Ergebnis lohnt den Aufwand.