Muss dafür wirklich ein eigener Rechner her?
Ich nutze KI inzwischen regelmäßig beim Programmieren. Code verstehen, eine Architektur diskutieren, Tests entwerfen oder einen Coding-Agenten auf eine Aufgabe ansetzen. Das ist praktisch. Man gewöhnt sich erstaunlich schnell daran.
Irgendwann kommt allerdings die Frage auf, ob wirklich jede dieser Anfragen durch irgendein Rechenzentrum laufen muss. Besonders dann, wenn es um größere Quellcodebestände, interne Dokumente oder einfach um die Freiheit geht, mit der eigenen Entwicklungsumgebung experimentieren zu können.
Also habe ich mir die naheliegende Frage gestellt: Was müsste ein Rechner können, auf dem ich meine KI weitgehend selbst betreibe?
Anfangs klingt das nach einer Hardwarefrage. Prozessor aussuchen, möglichst viel RAM hinein, ein Modell installieren, fertig. Je länger ich mich damit beschäftigt habe, desto deutlicher wurde allerdings, dass man sinnvollerweise mit etwas anderem beginnt: Was soll das System eigentlich leisten?
Aus dieser Überlegung ist im September 2026 ein ziemlich ausführliches Konzept geworden. Kein Einkaufszettel und auch kein bereits aufgebauter Server, sondern eine Entscheidungsgrundlage. Gerade weil ich am Ende nicht gekauft habe, finde ich die Erkenntnisse daraus interessant.
Ein Chatbot allein wäre mir zu wenig
Einen lokalen Chat kann man heute auf vielen Rechnern betreiben. Für meine Vorstellung eines KI-Servers reicht das allerdings nicht.
Ich möchte damit hauptsächlich Software entwickeln. Und das umfasst ziemlich unterschiedliche Aufgaben: Während ich tippe, soll eine sinnvolle Code-Ergänzung möglichst ohne merkliche Verzögerung auftauchen. Bei komplizierteren Fragen soll das Modell dagegen mehrere Dateien zusammen betrachten, Zusammenhänge erklären oder einen Fehler systematisch eingrenzen. Ein Coding-Agent soll außerdem Dateien ändern, Tests anstoßen und seine Arbeit anhand der Ergebnisse korrigieren können.
Für die Planung habe ich den Einsatz ungefähr so gewichtet:
-
Inline-Code-Completion50 %
Sehr kurze Antwortzeit, passende Ergänzungen, Projektkontext
-
Coding-Agent30 %
Tool-Nutzung, Fehlersuche, mehrere Arbeitsschritte, verlässliche Änderungen
-
Chat und technische Analyse20 %
Erklärungen, Architekturfragen, Code-Reviews, größere Zusammenhänge
Das ist keine wissenschaftlich ermittelte Statistik. Es ist meine Einschätzung meines eigenen Arbeitsalltags. Aber diese Gewichtung hat unmittelbare Folgen für die Architektur.
Ein großes Modell mag hervorragend über Softwarearchitektur diskutieren. Wenn ich nach jedem Tastendruck eine Sekunde oder länger auf eine Ergänzung warte, ist es als Inline-Completion trotzdem ungeeignet. Umgekehrt muss ein kleines, schnelles Modell nicht gleich eine anspruchsvolle Änderung über mehrere Module hinweg planen können.
Ein Modell für alles wäre bequem. Zwei unterschiedliche Modellklassen erschienen mir sinnvoller.
Schnell und stark sind zwei verschiedene Anforderungen
Die geplante Aufteilung war deshalb recht einfach:
- Ein schnelles Modell für die direkte Code-Ergänzung, insbesondere Fill-in-the-Middle. Es bekommt den relevanten Code vor und nach der Cursorposition und versucht, die Lücke sinnvoll zu ergänzen.
- Ein stärkeres Modell für Chat, Analyse, Architektur und Agentenaufgaben. Dort darf die Antwort etwas länger dauern, solange die Qualität stimmt.
- Optional ein drittes Modell für besonders aufwendige Reasoning-Aufgaben, wenn das Hauptmodell an Grenzen stößt.
Im damaligen Konzept standen dafür Qwen2.5-Coder-7B Base als schneller Kandidat, Qwen3.6-35B-A3B als stärkeres Hauptmodell und optional gpt-oss-120b. Das waren Referenzmodelle für eine spätere Bewertung, keine von mir auf dem geplanten Rechner vermessene Produktivkonfiguration. Gerade bei offenen KI-Modellen ist eine Modellliste von September 2026 keine zeitlose Empfehlung.
Der interessante Punkt ist ohnehin nicht der konkrete Modellname. Es ist die Aufgabentrennung. Ein guter Router kann je nach Anfrage ein passendes Modell auswählen. Außerdem müssen nicht zwangsläufig alle Modelle gleichzeitig geladen bleiben. Dadurch wird die Planung des Arbeitsspeichers deutlich entspannter.
Warum der KI-Server nicht auch noch mein Entwicklungsrechner sein soll
An dieser Stelle hätte ich mir leicht eine hübsche zusätzliche Baustelle aufmachen können: Linux-Server aufsetzen, alle Compiler installieren, Java- und C++-Toolchains spiegeln, Entwicklungsumgebungen nachziehen und am Ende herausfinden, warum ein Build auf dem Server anders reagiert als auf meinem Arbeitsrechner.
Darauf habe ich wenig Lust.
Meine eigentliche Entwicklungsumgebung läuft unter Windows. Dort liegen die Repositories, dort sind IntelliJ und VS Code, Git, Maven, CMake, Compiler, Tests und die übrigen Werkzeuge eingerichtet. Ein Coding-Agent braucht genau dort Zugriff, wenn er sinnvolle Arbeit erledigen soll.
Der lokale KI-Server soll deshalb vor allem Modelle ausführen und zusätzliche Dienste bereitstellen. Der Agent arbeitet weiterhin auf dem Entwicklungsrechner und spricht die KI über eine lokale API an.
Vereinfacht sieht die Idee so aus:
Windows-Entwicklungsrechner
├─ IntelliJ / VS Code
├─ Coding-Agent
├─ Git, Compiler, Build und Tests
└─ lokale API-Anfragen
|
| LAN
v
Lokaler KI-Server
├─ schnelles Completion-Modell
├─ starkes Coding-/Agentenmodell
├─ optionales Reasoning-Modell
├─ Dokumenten- und Repository-Suche
├─ Benutzerverwaltung / Wissensbereiche
└─ Weboberfläche
Windows-Entwicklungsrechner
├─ IntelliJ / VS Code
├─ Coding-Agent
├─ Git, Compiler, Build und Tests
└─ lokale API-Anfragen
|
| LAN
v
Lokaler KI-Server
├─ schnelles Completion-Modell
├─ starkes Coding-/Agentenmodell
├─ optionales Reasoning-Modell
├─ Dokumenten- und Repository-Suche
├─ Benutzerverwaltung / Wissensbereiche
└─ Weboberfläche
Das trennt zwei Verantwortlichkeiten, die gern in einen Topf geworfen werden: Der Agent führt Aktionen aus, das Sprachmodell liefert dafür Entscheidungen und Inhalte. Wer beides auf denselben Rechner verlagert, gewinnt nicht automatisch etwas. Unter Umständen verdoppelt er nur seine Wartungsarbeit.
Warum ich plötzlich über 128 GB RAM nachgedacht habe
Beim lokalen Betrieb großer Sprachmodelle landet man schnell bei einer ziemlich unspektakulären Grenze: dem Speicher.
Ein Modell besteht vereinfacht aus sehr vielen Gewichten. Die müssen während der Berechnung erreichbar sein. Bei einer klassischen Grafikkarte ist dafür vor allem der Grafikspeicher, also VRAM, entscheidend. Ein Modell, das vollständig in den schnellen Speicher passt, kann hervorragend laufen. Passt es nicht hinein, wird es häufig unangenehm. Zusätzliche Übertragungen und Auslagerungen können die Leistung deutlich drücken.
Natürlich kann man Modelle quantisieren. Statt Gewichte mit hoher Genauigkeit abzulegen, werden sie in kompakteren Formaten gespeichert. Damit sinkt der Speicherbedarf, allerdings nicht ohne mögliche Auswirkungen auf Genauigkeit und Verhalten. Auch der Kontext und die internen Zwischenspeicher brauchen Platz.
Für meine Planung war deshalb nicht allein interessant, wie viele Rechenoperationen eine GPU theoretisch schafft. Die Frage lautete eher: Welche Modellklasse bekomme ich überhaupt vollständig und sinnvoll in den verfügbaren Speicher?
Das brachte mich zu einer Hardwareklasse, die ich vorher nicht ernsthaft auf dem Schirm hatte: kompakte Systeme mit sehr großem Unified Memory.
Was an Unified Memory interessant ist
Bei einem Rechner mit dediziertem Grafikspeicher besitzen CPU und GPU typischerweise getrennte Speicherbereiche. Bei der betrachteten Ryzen-AI-Max-Plattform teilen sich CPU und integrierte GPU dagegen einen großen, schnellen LPDDR5X-Speicherpool.
Das bedeutet nicht, dass plötzlich sämtliche 128 GB kostenlos und ohne Einschränkungen als GPU-Speicher zur Verfügung stehen. Betriebssystem, Anwendungen, Modellserver und interne Reservierungen benötigen ebenfalls Speicher. Und eine integrierte GPU wird nicht allein durch viel RAM zur schnellsten GPU der Welt.
Aber es verschiebt die Grenze. Statt ein größeres Modell auf einer 16- oder 24-GB-Grafikkarte passend machen zu müssen, steht ein erheblich größerer gemeinsamer Speicherbereich zur Verfügung.
In meiner damaligen Bewertung sah das ungefähr so aus:
| Speicherausstattung | Einordnung für meinen geplanten Einsatz |
|---|---|
| 64 GB | Für größere Modelle, Kontext und weitere lokale Dienste zu knapp bemessen |
| 96 GB | Interessanter Zwischenbereich, aber mit weniger Reserve |
| 128 GB | Bevorzugte Referenzklasse für größere Modelle und zusätzliche Dienste |
| 192 GB | Technisch attraktiv, im September 2026 für meinen Bedarf wirtschaftlich nicht überzeugend |
128 GB waren also keine magische Zahl. Es war der damalige Kompromiss aus Modellgröße, Reserven, Geräteangebot und Preis. Sollte die nächste Modellgeneration kleiner und besser werden, kann diese Entscheidung schon wieder anders aussehen.
Der damalige Favorit: Ryzen AI Max+ 395
Als Referenzplattform landete ich beim AMD Ryzen AI Max+ 395, häufig unter dem Namen Strix Halo eingeordnet. Interessant waren für mich vor allem die Kombination aus leistungsfähiger integrierter Grafik, hoher Speicherbandbreite und der Möglichkeit, ein solches System in einem relativ kompakten Rechner unterzubringen.
Die beworbenen KI-Fähigkeiten und NPU-Kennzahlen waren dabei nicht mein ausschlaggebendes Kaufargument. Für den geplanten Betrieb offener Sprachmodelle war wesentlich wichtiger, welche Inferenz-Backends die GPU tatsächlich unterstützen und welche Geschwindigkeit sich damit bei echten Modellen erreichen lässt.
Das ist ein Unterschied, der in Produktwerbung gern untergeht. Eine beeindruckende TOPS-Zahl sagt mir noch nicht, wie schnell mein Coding-Agent ein Modell mit großem Kontext benutzen kann.
Zwei Mini-PCs auf der engeren Liste
Im September 2026 standen schließlich zwei Geräte auf meiner Liste:
| Gerät | Warum interessant | Meine damalige Einschätzung |
|---|---|---|
| ACEMAGIC M1A Pro+ mit 128 GB | Gute Ausstattung, mehrere SSD-Steckplätze, damals attraktives Preis-Leistungs-Verhältnis | Knapp vorn als Hardware-Referenz |
| GMKtec EVO-X2 mit 128 GB | Gleiche Prozessorplattform, mehr dokumentierte Community-Erfahrungen rund um Linux und lokale Modelle | Konservativere Alternative beim Software- und Community-Umfeld |
Der Vorsprung war keineswegs eindeutig. Gerade bei einem Rechner, der möglichst rund um die Uhr laufen soll, interessieren mich nicht nur Benchmarks. Ich möchte wissen, wie sich Kühlung, Lüfter, SSD, BIOS, Treiber und längere Lastphasen verhalten.
Beim ACEMAGIC gab es in der damaligen Recherche zudem Hinweise auf Stabilitätsprobleme eines Vorseriengeräts unter hoher GPU-Last. Das ist kein Beweis, dass Seriengeräte denselben Fehler besitzen. Aber es ist ein guter Grund, die konkrete Hardware-Revision zu prüfen und einen frisch gekauften Rechner nicht sofort als zuverlässigen Server zu betrachten.
Geplant waren deshalb eine eigene SSD, ein sauber installiertes Linux und ein ausführlicher Stabilitätstest. Ein schneller Benchmarklauf ist schön. Ein Rechner, der nach Stunden unter Last neu startet, hilft mir allerdings nicht besonders viel.
Linux, llama.cpp und die Frage nach dem richtigen Backend
Als Betriebssystem hatte ich Ubuntu 24.04 LTS vorgesehen. Nicht aus grundsätzlicher Abneigung gegen Windows, sondern weil sich ein Headless-Server unter Linux gut automatisieren und verwalten lässt und die interessanten KI-Werkzeuge dort ein breites Ökosystem haben.
Bei der Modellinferenz war llama.cpp die damalige Ausgangsbasis. Die Software unterstützt unter anderem GGUF-Modelle und unterschiedliche Ausführungs-Backends.
Besonders spannend fand ich die Frage Vulkan oder ROCm?
ROCm ist AMDs Compute-Softwarestack. Vulkan kennt man oft als Grafik-API, es lässt sich aber auch für Berechnungen verwenden. Welcher Weg auf einer konkreten AMD-Plattform besser ist, hängt unter anderem von Treibern, Modell, Quantisierung und Speicherzugriffen ab.
Meine ursprüngliche Tendenz ging Richtung ROCm. Nach der Recherche stand im Konzept allerdings etwas Vernünftigeres: Beide Backends mit denselben Modellen und realistischen Aufgaben testen, statt sich vorher festzulegen.
Das ist weniger elegant als eine klare Entscheidung auf dem Papier. Dafür ist es deutlich näher an der Realität. Softwarestacks ändern sich, und was in einem Benchmark schneller ist, muss nicht bei jeder Modellgröße und jedem Kontext genauso aussehen.
Deshalb soll auch die Oberfläche austauschbar bleiben. Open WebUI war damals ein Kandidat für den Browser, Continue für die Integration in IDEs. Beides sind Werkzeuge, keine Architekturgesetze. Entscheidend ist für mich, dass die Komponenten über vernünftige Schnittstellen miteinander reden.
Lokal heißt nicht automatisch privat und sicher
Ein eigener KI-Rechner hat einen offensichtlichen Reiz: Quellcode, Dokumente und Gespräche müssen für die Modellberechnung nicht automatisch zu einem externen Dienst geschickt werden.
Nur wäre es ziemlich naiv, daraus sofort „alles sicher“ abzuleiten.
Ein lokaler Modellserver kann falsch konfiguriert sein. Eine Weboberfläche kann zu weit im Netzwerk erreichbar sein. Ein Agent kann mit zu großzügigen Dateirechten arbeiten. Und wenn mehrere Menschen denselben Server verwenden, muss man deren private Daten auch tatsächlich voneinander trennen.
Mein Konzept sah deshalb getrennte Benutzerbereiche, definierte Zugriffsrechte für Wissensbestände und eine projektbezogene Regelung für Cloud-Zugriffe vor. Die Grundidee: lokal als Standard, Cloud nur nach bewusster Freigabe.
Das betrifft auch die Suche nach Informationen im Internet. Eine Fehlermeldung oder ein allgemeiner Bibliotheksname darf unter Umständen für eine Websuche verwendet werden. Der komplette vertrauliche Quellcode sollte dafür nicht ungefragt mitgeschickt werden.
Die unangenehme Wahrheit ist: Datenschutz entsteht nicht dadurch, dass ein Server im eigenen Haus steht. Man muss das System trotzdem vernünftig entwerfen und betreiben.
Ein Server für mehr als nur Code?
Obwohl Coding der klare Schwerpunkt war, hatte ich weitere Einsatzmöglichkeiten vorgesehen. Zum Beispiel eine lokale Wissensbasis für PDFs und technische Dokumente, die Auswertung von Screenshots oder Fotos sowie eine Weboberfläche für alltägliche Fragen.
Auch mein Projekt MITEO bewegt sich in diesem Umfeld. Dort geht es um eine lokal laufende, sprachgesteuerte Assistenz für ältere Menschen. Das ist ein anderer Anwendungsfall, mit eigenen Anforderungen an Reaktionszeit, Bedienbarkeit, Zuverlässigkeit und Datenschutz.
Die Idee eines gemeinsamen lokalen KI-Backends ist naheliegend. Ich würde aber nicht einfach behaupten, dass ein leistungsfähiger Coding-Server damit automatisch der richtige Unterbau für MITEO ist. Für eine Sprachassistenz können ein kleineres Modell, geringere Latenz und ein möglichst robuster Betrieb wichtiger sein als maximale Modellgröße. Ob und wie sich solche Systeme später sinnvoll verbinden lassen, müsste man gesondert ausprobieren.
Was ich vor einem Kauf wirklich messen möchte
Eine theoretisch passende Hardwarekonfiguration ist noch keine praxistaugliche Lösung. In meinem Konzept stand deshalb auch, wie ich einen späteren Kandidaten beurteilen würde.
Nicht nur mit einem hübschen Tokens-pro-Sekunde-Wert aus einem Herstellerdiagramm, sondern mit Aufgaben, die zu meinem Alltag passen:
- Completion-Latenz: Wie schnell erscheinen brauchbare Vorschläge in Java, C und C++?
- Agentenaufgaben: Kann das Modell in einem realen Repository gezielt Änderungen durchführen, Tests auswerten und Fehler korrigieren?
- Langer Kontext: Was passiert mit Geschwindigkeit und Qualität, wenn deutlich mehr Quellcode einbezogen wird?
- Multimodale Aufgaben: Wie gut versteht das Modell einen Screenshot, ein Datenblatt oder ein Foto einer Schaltung?
- Dauerbetrieb: Wie verhalten sich Leistungsaufnahme, Temperatur, Lüfter und Stabilität über mehrere Stunden?
- Speicher und Modellwechsel: Wie lange dauert das Laden? Wie zuverlässig funktioniert der Wechsel zwischen schnellem und starkem Modell?
Mein damaliges Leistungsziel lag für die normale Interaktion grob bei mindestens 30 erzeugten Tokens pro Sekunde. Auch das ist keine universelle Qualitätsgrenze. Bei Inline-Completion zählen unter Umständen die Zeit bis zum ersten Token und die Qualität der Ergänzung viel mehr. Bei einer schwierigen Agentenaufgabe akzeptiere ich dagegen eher Wartezeit, wenn am Ende eine saubere Änderung herauskommt.
Kurz gesagt: Ein KI-Server muss nicht im Benchmark gewinnen. Er muss zu meiner Arbeit passen.
Und warum habe ich ihn dann nicht gekauft?
Nach der ganzen Recherche hätte der nächste Schritt eigentlich die Bestellung sein können. Die Hardware war eingegrenzt, die Architektur skizziert und die Modellklassen standen fest.
Ich habe mich trotzdem entschieden, den Kauf um ungefähr ein Jahr zu verschieben.
Der Grund ist ziemlich nüchtern. In diesem Bereich verändern sich Modelle, Inferenzsoftware und Hardware schnell. Ein teurer Mini-PC kann im September eine vernünftige Wahl sein und ein Jahr später von einer deutlich besseren Kombination überholt werden. Gerade wenn man kein akutes Problem lösen muss, ist Nichtkaufen manchmal die technisch und wirtschaftlich sauberste Entscheidung.
Deshalb enthält mein Konzept keinen endgültigen Kaufbeschluss, sondern eine Referenz für die spätere Neubewertung: Was muss ein neues System besser können als die damalige Ryzen-AI-Max+-Konfiguration mit 128 GB? Ist ein kleineres Modell inzwischen gut genug? Gibt es schnellere Hardware mit ähnlich großem nutzbarem Speicher? Haben sich Treiber und Preise verbessert?
Dabei muss ich auch meine ursprünglichen Annahmen kritisch prüfen. Vielleicht werden Modelle effizienter, als ich erwartet habe. Vielleicht lohnt sich eine klassische GPU-Lösung wieder mehr. Vielleicht decken kleine lokale Modelle mit gutem Repository-Kontext einen größeren Teil meines Bedarfs ab als gedacht.
Einen teuren Rechner zu kaufen, nur weil man ihn nach wochenlanger Recherche endlich ausgewählt hat, wäre jedenfalls keine besonders überzeugende Begründung.
Was von der Planung bleibt
Den Server habe ich bislang nicht aufgebaut. Trotzdem war die Arbeit nicht umsonst. Ich weiß jetzt wesentlich genauer, welche Fragen ich vor einer solchen Anschaffung beantworten muss und wo mich technische Datenblätter eher in die Irre führen können.
Vor allem hat sich für mich eine Erkenntnis herausgeschält: Lokale KI ist weniger eine Frage des größten Modells als eine Frage der passenden Architektur.
Ein schnelles Modell an der richtigen Stelle, ein stärkeres Modell für anspruchsvolle Aufgaben, eine klare Trennung zwischen Agent und Inferenz, vernünftige Datenschutzregeln und Hardware, die das Ganze zuverlässig betreibt. Das ist für mich interessanter als ein einzelner spektakulärer Benchmarkwert.
Und falls ich beim nächsten Anlauf doch wieder mehr Zeit mit Modellen, Treibern und Speicherbandbreite verbringe als ursprünglich vorgesehen, wäre das immerhin keine besonders überraschende Entwicklung.
Einordnung: Dieser Artikel beschreibt meine Planung und Bewertung aus dem September 2026, nicht einen bereits realisierten Server. Modelle, Preise und Hardwarekandidaten müssen vor einer späteren Kaufentscheidung neu geprüft werden.