KI & GPU
LLM selbst hosten mit Ollama: Anleitung für GPU-Server
Betreibe dein eigenes großes Sprachmodell auf einem dedizierten GPU-Server. Mit Ollama läuft das LLM in unter 15 Minuten, inklusive Modellwahl, eigener API und Absicherung.
Betreibe dein eigenes großes Sprachmodell auf einem dedizierten GPU-Server. Mit Ollama läuft das LLM in unter 15 Minuten, inklusive Modellwahl, eigener API und Absicherung.
Du willst ein großes Sprachmodell betreiben, ohne deine Prompts an OpenAI oder einen US-Cloud-Anbieter zu schicken? Mit Ollama auf einem dedizierten GPU-Server läuft dein eigenes LLM in unter 15 Minuten. Du behältst die volle Kontrolle, zahlst eine feste Monatsrate statt pro Token, und deine Daten bleiben auf deinem Server. Diese Anleitung geht jeden Schritt durch, von der Installation bis zur abgesicherten API.
GPU-Server mieten, Ollama installieren, ollama run ausführen, fertig. Modelle bis 14B laufen auf kleinen GPUs, für 70B brauchst du 48 GB VRAM wie auf der RTX 6000 Ada.
Drei Gründe sprechen für Self-Hosting. Erstens der Datenschutz: Prompts und Antworten verlassen deinen Server nicht, was bei Kunden-, Geschäfts- oder Gesundheitsdaten und für die DSGVO entscheidend ist. Zweitens die Kosten: Du zahlst eine feste Monatsrate statt pro Token, was sich bei hohem Volumen schnell rechnet. Drittens die Unabhängigkeit: kein Rate-Limiting, keine abgekündigten Modelle, kein Anbieter, der dir die API unter den Füßen wegzieht.
Wie viel VRAM du brauchst, hängt vom größten Modell ab, das du fahren willst. Als Faustregel bei 4-bit-Quantisierung:
| Modellgröße | VRAM (4-bit) | Passende GPU |
|---|---|---|
| 7B bis 8B | ca. 6 GB | RTX 4000 Ada (20 GB) |
| 13B bis 14B | ca. 10 GB | RTX 4000 Ada (20 GB) |
| 32B bis 34B | ca. 22 GB | RTX 6000 Ada (48 GB) |
| 70B | ca. 42 GB | RTX 6000 Ada (48 GB) |
Diese vier Schritte bringen dich von einem frischen Server zum laufenden Modell.
Verbinde dich mit und bring das System auf den neuesten Stand:
Auf einem GPU-Server von ComputeBox ist der NVIDIA-Treiber schon installiert. Prüf mit nvidia-smi, ob die Karte erkannt wird:
Du brauchst Treiber 550+ und CUDA 12+. Fehlt die Ausgabe, installier den Treiber neu oder öffne ein Support-Ticket.
Das offizielle Skript erkennt die GPU automatisch und richtet Ollama als systemd-Dienst ein:
Danach läuft der Dienst im Hintergrund und startet beim Booten mit. Den Status prüfst du mit systemctl status ollama.
Prüf kurz, ob das Modell wirklich auf der GPU rechnet:
In der Spalte PROCESSOR sollte 100% GPU stehen. Taucht dort CPU auf, passt das Modell nicht vollständig in den VRAM. Nimm dann eine kleinere Variante, eine stärkere Quantisierung oder eine GPU mit mehr Speicher.
Ollama hat eine große Modellbibliothek. Diese Familien sind gut getestet und ein solider Startpunkt:
| Modell | Stärke | Befehl |
|---|---|---|
| Llama 3.1 / 3.3 | Allrounder, gut auf Deutsch | ollama run llama3.1:8b |
| Qwen 2.5 | Stark beim Coden und Reasoning | ollama run qwen2.5:14b |
| Mistral Small | Schnell und kompakt | ollama run mistral-small |
| Gemma 2 | Effizient für kleine GPUs | ollama run gemma2:9b |
| DeepSeek-R1 | Reasoning-Modell | ollama run deepseek-r1:14b |
Hinter dem Doppelpunkt steht der Tag mit Größe und Variante. Ohne Tag lädt Ollama eine sinnvolle Standardgröße. Die jeweils aktuellsten Modelle findest du in der offiziellen Ollama-Bibliothek.
Ollama nutzt standardmäßig 4-bit-Quantisierung (Q4_K_M). Das halbiert den VRAM-Bedarf gegenüber 16-bit bei nur minimalem Qualitätsverlust. Genau deshalb passt ein 70B-Modell in 48 GB. Wenn du maximale Qualität willst, gibt es Tags wie :q8_0, die mehr Speicher brauchen.
Der eigentliche Nutzen kommt über die API. Ollama stellt sie auf Port 11434 bereit, sodass du dein Modell aus eigenem Code ansprichst. Ein schneller Test mit curl:
Praktischer ist oft, dass Ollama auch das OpenAI-Format spricht. Bestehender Code, der das OpenAI-SDK nutzt, funktioniert fast unverändert. Du zeigst nur auf eine andere Basis-URL:
Wer lieber klickt als tippt, installiert Open WebUI, die populärste Oberfläche für lokale Modelle. Am schnellsten geht das per Docker. Wie du Docker auf einem Server einrichtest, steht in unserem Docker-Compose-Tutorial.
Die Oberfläche erreichst du danach unter http://DEINE-SERVER-IP:3000. Beim ersten Aufruf legst du ein Admin-Konto an. Damit hast du ein privates ChatGPT, das komplett auf deinem Server läuft.
Gib Port 11434 nie ungeschützt ins Internet frei. Eine offene Ollama-API kann jeder ansprechen, der die IP kennt. Das kostet dich Rechenzeit und ist ein Sicherheitsloch.
Standardmäßig lauscht Ollama nur auf 127.0.0.1, also lokal. Das ist sicher. Für den Zugriff von außen gibt es zwei saubere Wege.
Variante 1 ist ein SSH-Tunnel, am einfachsten für eine einzelne Person:
Danach sprichst du die API lokal über localhost:11434 an, als liefe sie auf deinem Rechner.
Variante 2 ist ein Reverse Proxy mit Authentifizierung, gedacht für Teams und Produktion. Dabei setzt du Ollama oder Open WebUI hinter Caddy oder Nginx mit HTTPS und Login. Die Grundabsicherung des Servers, also Firewall, SSH-Härtung und Fail2ban, zeigt unser VPS-Sicherheits-Tutorial.
OLLAMA_KEEP_ALIVE=-1 bleibt das Modell geladen und muss nicht bei jeder Anfrage neu in den VRAM.num_ctx) frisst zusätzlichen VRAM.OLLAMA_NUM_PARALLEL legt fest, wie viele Anfragen gleichzeitig laufen. Sinnvoll, sobald mehrere Leute zugreifen.watch -n1 nvidia-smi zeigt VRAM und Auslastung in Echtzeit.ollama ps zeigt CPU statt GPUCUDA driver version is insufficient for CUDA runtime versionError: could not connect to ollama appEin 70B-Modell läuft bei 4-bit-Quantisierung bequem in 48 GB, jedes kleinere sowieso. Für unquantisierte 70B-Inferenz nimmst du zwei GPUs.
Für interne Tools, Prototypen und moderate Last ja. Wenn du hohen parallelen Durchsatz brauchst, ist vLLM die bessere Wahl. Dazu kommt ein eigenes Tutorial.
Ja, solange die Summe in den VRAM passt. Ollama lädt Modelle bei Bedarf und hält sie im Speicher.
RTX 6000 Ada mit 48 GB VRAM, dediziert und ohne Time-Slicing, aus deutschen Rechenzentren. In Minuten startklar.
RTX 6000 Ada konfigurieren
Llama 3.1 in der 8B-Variante ist ein schneller Allrounder zum Einstieg:
Beim ersten Aufruf lädt Ollama das Modell (ein paar GB), danach landest du direkt im Chat. Mit Ctrl + D oder dem Befehl /bye beendest du die Sitzung.
Nein, Ollama läuft nativ als systemd-Dienst. Docker brauchst du nur für Zusatztools wie Open WebUI.
Ja. Bei selbst gehostetem Ollama bleiben Prompts und Antworten auf deinem Server. Bei ComputeBox steht der in einem DSGVO-konformen Rechenzentrum in Deutschland.
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 550.54 Driver Version: 550.54 CUDA Version: 12.4 |
|-------------------------------+----------------------+----------------------+
| GPU Name | Memory-Usage | GPU-Util |
| 0 RTX 6000 Ada Generation | 0MiB / 49140MiB | 0% |
+-------------------------------+----------------------+----------------------+apt update && apt upgrade -ycurl -fsSL https://ollama.com/install.sh | shollama pscurl http://localhost:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Erklaere Quantisierung in einem Satz.",
"stream": false
}'from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama", # beliebig, wird lokal nicht geprueft
)
resp = client.chat.completions.create(
model="llama3.1:8b",
messages=[{"role": "user", "content": "Schreibe ein Haiku ueber GPUs."}],
)
print(resp.choices[0].message.content)docker run -d -p 3000:8080 \
--add-host=host.docker.internal:host-gateway \
-v open-webui:/app/backend/data \
--name open-webui --restart always \
ghcr.io/open-webui/open-webui:mainssh -L 11434:localhost:11434 root@DEINE-SERVER-IPollama run llama3.1:8b