Ollama auf Linux: Installation und Einrichtung

Was dieser Artikel über Ollama auf Linux behandelt

Installation von Ollama auf Ubuntu, Debian und Fedora über das offizielle Install-Script und manuell
GPU-Support für Nvidia CUDA und AMD ROCm einrichten und prüfen
systemd-Service verstehen, starten, stoppen und dauerhaft konfigurieren
Erstes Modell herunterladen und über die Kommandozeile sowie die API nutzen
Häufige Probleme und Stolpersteine erkennen und selbst beheben

Einleitung: Ollama auf Linux verständlich erklärt

Ollama ist ein kompaktes Tool, mit dem Du grosse Sprachmodelle lokal auf Deinem eigenen Rechner ausführen kannst. Auf Linux läuft Ollama besonders stabil und ressourcenschonend, weil es als Hintergrundservice über systemd betrieben wird. Du brauchst keine Cloud, kein Abo und keine ständige Internetverbindung, sobald ein Modell einmal heruntergeladen ist.

In dieser Anleitung gehe ich jeden Schritt durch, den Du für eine funktionierende Ollama-Installation auf Linux brauchst. Dabei richte ich mich an Anfängerinnen und Anfänger, die noch nie ein lokales Sprachmodell gestartet haben. Du bekommst konkrete Befehle, Erklärungen dazu und Hinweise, wenn es an einer Stelle hakt.

Warum brauche ich diese Anleitung?

Stell Dir vor, Du möchtest ein Sprachmodell für private Gespräche oder zum Experimentieren nutzen, ohne dass Deine Daten an einen Cloud-Anbieter geschickt werden. Du hast einen Linux-Rechner mit einer Grafikkarte und willst einfach loslegen. Ohne eine strukturierte Anleitung stehst Du schnell vor Fragen wie: Wo landen die Modelle auf der Festplatte? Wie starte ich Ollama automatisch beim Hochfahren? Und warum nutzt das Modell die GPU scheinbar nicht?

Genau hier setzt dieser Artikel an. Er führt Dich von der Installation über die GPU-Einrichtung bis zur API-Nutzung Schritt für Schritt durch alle relevanten Punkte. Am Ende hast Du eine lauffähige Ollama-Installation, die beim Systemstart automatisch hochfährt und über die Kommandozeile sowie die API erreichbar ist.

Ollama auf Linux kurz erklärt

Ollama ist ein Open-Source-Tool, das lokale Sprachmodelle lädt, verwaltet und ausführt. Auf Linux installierst Du es über ein einfaches Shell-Script, das die Binärdatei herunterlädt und einen systemd-Service einrichtet. Dieser Service sorgt dafür, dass Ollama im Hintergrund läuft und über einen lokalen HTTP-Server auf Port 11434 erreichbar ist. Du interagierst mit Ollama entweder über das Kommandozeilen-Tool ollama oder über die REST-API.

Die Modelle selbst werden standardmäßig unter /usr/share/ollama/.ollama/models gespeichert. Du kannst diesen Pfad über die Umgebungsvariable OLLAMA_MODELS anpassen, wenn Du beispielsweise eine separate Festplatte oder Partition nutzen möchtest.

Für wen ist diese Anleitung gedacht?

Diese Anleitung richtet sich an Linux-Nutzerinnen und Nutzer, die Ollama zum ersten Mal installieren. Du solltest grundlegende Kommandozeilen-Kenntnisse mitbringen, also wissen, wie Du ein Terminal öffnest und Befehle ausführst. Vorkenntnisse mit Sprachmodellen oder systemd sind hilfreich, aber nicht zwingend erforderlich.

Wenn Du bereits Ollama auf Windows oder macOS nutzt und auf Linux wechseln möchtest, findest Du hier die spezifischen Unterschiede und Konfigurationsmöglichkeiten, die Linux bietet.

Wichtige Begriffe rund um Ollama auf Linux

Begriff	Erklärung
Ollama	Open-Source-Tool zum lokalen Ausführen von Sprachmodellen
systemd	Init-System und Service-Manager auf modernen Linux-Distributionen
curl	Kommandozeilen-Tool zum Herunterladen von Dateien und API-Aufrufen
apt	Paketmanager auf Debian und Ubuntu
dnf	Paketmanager auf Fedora
CUDA	Nvidia-Plattform für GPU-beschleunigtes Rechnen
ROCm	AMD-Plattform für GPU-beschleunigtes Rechnen
OLLAMA_MODELS	Umgebungsvariable für den Speicherort der Modelle
OLLAMA_HOST	Umgebungsvariable für die Adresse, an der Ollama lauscht
Service	Hintergrundprozess, der von systemd verwaltet wird
Journalctl	Tool zum Lesen der systemd-Protokolle

Voraussetzungen

Bevor Du Ollama installierst, solltest Du folgende Voraussetzungen prüfen:

Linux-Distribution: Ubuntu 22.04 oder neuer, Debian 12 oder neuer, Fedora 39 oder neuer. Andere Distributionen funktionieren ebenfalls, solange sie systemd nutzen.
RAM: Mindestens 8 GB für kleine Modelle, 16 GB oder mehr für Modelle ab 7 Milliarden Parametern.
Festplattenplatz: Etwa 5 GB für Ollama selbst plus 4 bis 40 GB pro Modell, je nach Grösse.
GPU-Treiber: Wenn Du eine Nvidia-GPU nutzen möchtest, müssen die proprietären Treiber installiert sein. Für AMD-GPUs brauchst Du ROCm.
Internetverbindung: Für die Installation und den ersten Modell-Download erforderlich.

Ob Deine Nvidia-GPU erkannt wird, prüfst Du mit folgendem Befehl:

nvidia-smi

Wenn Dir eine Tabelle mit Deiner Grafikkarte und der Treiberversion angezeigt wird, ist der Treiber korrekt installiert. Ohne Ausgabe oder mit einer Fehlermeldung musst Du zuerst die Nvidia-Treiber installieren.

Schritt 1: Ollama installieren

Die einfachste Methode ist das offizielle Install-Script. Öffne ein Terminal und führe folgenden Befehl aus:

curl -fsSL https://ollama.com/install.sh | sh

Dieses Script lädt die Ollama-Binärdatei herunter, richtet den systemd-Service ein und startet Ollama automatisch. Nach Abschluss der Installation kannst Du prüfen, ob Ollama läuft:

ollama --version

Die Ausgabe zeigt Dir die installierte Version. Wenn Du eine Fehlermeldung erhältst, dass der Befehl nicht gefunden wurde, starte Dein Terminal neu oder führe source ~/.bashrc aus.

Manuelle Installation

Falls Du das Script nicht nutzen möchtest oder Deine Distribution nicht unterstützt wird, kannst Du Ollama manuell installieren:

# Binärdatei herunterladen
sudo curl -L https://ollama.com/download/ollama-linux-amd64 -o /usr/local/bin/ollama
sudo chmod +x /usr/local/bin/ollama

# Benutzer und Gruppe anlegen
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama

Danach musst Du die systemd-Service-Datei selbst anlegen. Mehr dazu erfährst Du im Abschnitt über systemd weiter unten.

Schritt 2: GPU-Support einrichten

Nvidia CUDA

Wenn Du eine Nvidia-GPU hast und die proprietären Treiber installiert sind, erkennt Ollama CUDA automatisch. Du musst keine zusätzlichen Pakete installieren. Prüfe nach der Installation, ob Ollama die GPU nutzt:

ollama ps

In der Ausgabe siehst Du unter der Spalte PROCESSOR entweder 100% GPU oder eine Mischung aus CPU und GPU. Steht dort 100% CPU, nutzt Ollama die GPU nicht. In diesem Fall prüfe mit nvidia-smi, ob der Treiber funktioniert.

AMD ROCm

Für AMD-Grafikkarten benötigt Ollama ROCm. Auf Ubuntu und Debian kannst Du ROCm über den offiziellen AMD-Installer einrichten. Fedora-Nutzer finden ROCm in den Repositories. Nach der Installation von ROCm starte den Ollama-Service neu:

sudo systemctl restart ollama

Prüfe danach ebenfalls mit ollama ps, ob die GPU erkannt wird. Nicht jede AMD-Grafikkarte wird von ROCm unterstützt, ältere Modelle funktionieren unter Umständen nur mit CPU.

Schritt 3: systemd-Service verstehen

Ollama wird auf Linux als systemd-Service betrieben. Das bedeutet, Ollama läuft im Hintergrund und startet automatisch beim Hochfahren des Systems. Die Service-Datei liegt unter /etc/systemd/system/ollama.service und sieht standardmässig so aus:

[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

[Install]
WantedBy=default.target

Die wichtigsten Befehle zur Steuerung des Services:

# Status abfragen
sudo systemctl status ollama

# Service starten
sudo systemctl start ollama

# Service stoppen
sudo systemctl stop ollama

# Service neu starten
sudo systemctl restart ollama

# Autostart aktivieren
sudo systemctl enable ollama

# Autostart deaktivieren
sudo systemctl disable ollama

Die Protokolle des Services liest Du mit journalctl:

# Letzte Protokolle anzeigen
sudo journalctl -u ollama -n 50

# Protokolle live verfolgen
sudo journalctl -u ollama -f

Schritt 4: Erstes Modell starten

Nach der Installation kannst Du sofort ein Modell herunterladen und starten. Für den Anfang empfiehlt sich ein kleines Modell wie llama3.2:

ollama run llama3.2

Ollama lädt das Modell automatisch herunter, bevor es startet. Der Download kann je nach Modellgrösse und Internetverbindung mehrere Minuten dauern. Sobald das Modell geladen ist, erscheint ein Eingabe-Prompt, in dem Du direkt mit dem Modell chatten kannst.

Mit dem Befehl /bye verlässt Du den Chat. Eine Übersicht aller heruntergeladenen Modelle bekommst Du mit:

ollama list

Weitere Modelle findest Du im offiziellen Modell-Verzeichnis unter ollama.com/library. Mehr zum Verwalten von Modellen erfährst Du im Artikel Modelle verwalten.

Schritt 5: API nutzen

Ollama stellt eine REST-API auf http://localhost:11434 bereit. Du kannst diese API mit curl oder aus jeder Programmiersprache ansprechen, die HTTP-Requests unterstützt.

API mit curl aufrufen

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Erkläre systemd in drei Sätzen.",
  "stream": false
}'

Die Antwort kommt als JSON-Objekt zurück. Mit "stream": false bekommst Du die komplette Antwort auf einmal. Ohne diesen Parameter wird die Antwort stückweise gestreamt.

API mit Python aufrufen

import requests

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "llama3.2",
        "prompt": "Erkläre systemd in drei Sätzen.",
        "stream": False
    }
)

print(response.json()["response"])

Eine ausführliche Beschreibung aller API-Endpunkte findest Du im Artikel Ollama API.

Konfiguration über Umgebungsvariablen

Ollama lässt sich über mehrere Umgebungsvariablen konfigurieren. Die wichtigsten sind:

OLLAMA_MODELS: Legt fest, wo die Modelle gespeichert werden. Standard ist ~/.ollama/models beim jeweiligen Benutzer bzw. /usr/share/ollama/.ollama/models beim Service.
OLLAMA_HOST: Bestimmt die Adresse und den Port, an dem Ollama lauscht. Standard ist 127.0.0.1:11434.
OLLAMA_ORIGINS: Steuert, welche Origins für CORS zugelassen sind, wichtig wenn Du Ollama aus einem Browser-Frontend ansprechen möchtest.

Diese Variablen trägst Du in die systemd-Service-Datei ein. Öffne die Datei mit einem Editor:

sudo systemctl edit ollama

Es öffnet sich eine leere Datei, in der Du Override-Einstellungen eintragen kannst. Beispiel:

[Service]
Environment="OLLAMA_MODELS=/mnt/data/ollama-models"
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_ORIGINS=http://localhost:3000,http://localhost:8080"

Speichere die Datei und lade systemd neu:

sudo systemctl daemon-reload
sudo systemctl restart ollama

Ausführliche Informationen zu allen Konfigurationsmöglichkeiten findest Du im Artikel Konfiguration.

Ollama unter Ubuntu/Debian vs Fedora

Die Installation über das offizielle Script funktioniert auf Ubuntu, Debian und Fedora gleichermassen. Es gibt jedoch einige Unterschiede in den Details:

Aspekt	Ubuntu / Debian	Fedora
Paketmanager	apt	dnf
Nvidia-Treiber	Über `ubuntu-drivers autoinstall` oder manuell	Über `dnf install akmod-nvidia`
ROCm	Über AMD-Installer	Über `dnf install rocm`
Firewall	ufw (falls installiert)	firewalld (standardmässig aktiv)

Auf Fedora musst Du darauf achten, dass firewalld den Port 11434 blockiert, wenn Du Ollama aus dem Netzwerk erreichbar machen willst. Öffne den Port mit:

sudo firewall-cmd --permanent --add-port=11434/tcp
sudo firewall-cmd --reload

Auf Ubuntu mit ufw gilt entsprechend:

sudo ufw allow 11434/tcp

Weitere Grundlagen zu Ubuntu findest Du im Artikel Ubuntu.

Typische Stolpersteine bei Ollama auf Linux

GPU wird nicht erkannt: Ollama nutzt nur die CPU, obwohl eine Grafikkarte verbaut ist. Ursache ist oft ein fehlender oder veralteter Treiber. Prüfe mit nvidia-smi bzw. rocminfo, ob die GPU vom System erkannt wird.
Service startet nicht: Wenn systemctl status ollama einen Fehler zeigt, lohnt sich ein Blick in die Protokolle mit journalctl -u ollama -n 50. Häufig ist ein falscher Pfad in der Service-Datei oder ein Berechtigungsproblem.
Modelle landen auf der falschen Festplatte: Standardmässig speichert Ollama Modelle im Home-Verzeichnis des Service-Benutzers. Wenn dort wenig Platz ist, setze OLLAMA_MODELS auf eine Partition mit ausreichend Speicherplatz.
Port 11434 ist belegt: Läuft bereits ein anderer Dienst auf diesem Port, startet Ollama nicht. Ändere den Port über OLLAMA_HOST, zum Beispiel auf 127.0.0.1:11435.
Berechtigungsprobleme beim Service-Benutzer: Der Benutzer ollama braucht Lese- und Schreibrechte im Modell-Verzeichnis. Wenn Du OLLAMA_MODELS änderst, stelle sicher, dass der Benutzer ollama dort schreiben darf.
CORS-Fehler aus dem Browser: Wenn Du ein Web-Frontend nutzt und Ollama aus dem Browser ansprechen willst, musst Du OLLAMA_ORIGINS setzen. Ohne diese Einstellung blockiert Ollama Anfragen aus dem Browser.
Veraltete Ollama-Version: Ältere Versionen unterstützen manche Modelle nicht. Aktualisiere Ollama, indem Du das Install-Script erneut ausführst.

Weitere Lösungen zu häufigen Fehlern findest Du im Artikel Fehlerbehebung.

Hardware, Kosten und Sicherheit bei Ollama auf Linux

Hardware

Für eine brauchbare Geschwindigkeit ist eine GPU empfehlenswert. Eine Nvidia-GPU mit 8 GB VRAM reicht für Modelle bis etwa 7 Milliarden Parameter. Für grössere Modelle brauchst Du mehr VRAM oder Du akzeptierst eine langsamere Ausführung auf der CPU. Mehr zum Thema CPU versus GPU findest Du im Artikel CPU vs. GPU.

Kosten

Ollama selbst ist kostenlos und Open Source. Die Kosten entstehen ausschließlich durch die Hardware. Wenn Du bereits einen Linux-Rechner mit einer geeigneten Grafikkarte hast, fallen keine zusätzlichen Kosten an.

Sicherheit

Ollama lauscht standardmässig nur auf 127.0.0.1, ist also nur lokal erreichbar. Wenn Du OLLAMA_HOST auf 0.0.0.0 setzt, wird Ollama im gesamten Netzwerk erreichbar. In diesem Fall solltest Du eine Firewall einrichten und den Zugriff einschränken. Modelle und Konversationen bleiben auf Deinem Rechner, es werden keine Daten an externe Server übertragen.

Allgemeine Grundlagen zum lokalen Betrieb von Sprachmodellen findest Du im Artikel LLM lokal betreiben.

Weiterführende Links und Infos zu Ollama auf Linux

Ollama Übersicht - Allgemeine Einführung in Ollama
Ollama Installation - Installation auf anderen Betriebssystemen
Ollama mit Docker - Ollama in Containern betreiben
Modelle verwalten - Modelle herunterladen, aktualisieren und löschen
Konfiguration - Alle Konfigurationsmöglichkeiten im Überblick
Fehlerbehebung - Lösungen für häufige Probleme
Ollama API - API-Endpunkte und Beispiele
LLM lokal betreiben - Grundlagen lokaler Sprachmodelle
CPU vs. GPU - Hardware-Grundlagen
Ubuntu - Grundlagen zu Ubuntu

FAQ: Ollama auf Linux - Typische Fragen

Wie viel RAM brauche ich für Ollama auf Linux?

Mindestens 8 GB für kleine Modelle wie llama3.2 mit 3 Milliarden Parametern. Für Modelle mit 7 bis 8 Milliarden Parametern sind 16 GB empfehlenswert. Grössere Modelle ab 13 Milliarden Parametern profitieren deutlich von 32 GB oder mehr.

Wo speichert Ollama die Modelle auf Linux?

Standardmässig unter /usr/share/ollama/.ollama/models, wenn Ollama als systemd-Service läuft. Du kannst den Pfad über die Umgebungsvariable OLLAMA_MODELS ändern.

Brauche ich eine GPU für Ollama?

Nein, Ollama läuft auch auf der CPU. Eine GPU beschleunigt die Antwortgenerierung aber erheblich. Auf der CPU sind Modelle mit 3 bis 7 Milliarden Parametern noch brauchbar, grössere Modelle werden sehr langsam.

Wie aktualisiere ich Ollama auf Linux?

Führe das Install-Script erneut aus: curl -fsSL https://ollama.com/install.sh | sh. Die bestehende Installation wird überschrieben, Deine Modelle und Konfiguration bleiben erhalten.

Startet Ollama automatisch beim Hochfahren?

Ja, wenn der systemd-Service aktiviert ist. Prüfe mit systemctl is-enabled ollama. Steht dort enabled, startet Ollama automatisch. Falls nicht, aktiviere den Autostart mit sudo systemctl enable ollama.

Kann ich Ollama ohne sudo installieren?

Das Install-Script benötigt sudo-Rechte, weil es die Binärdatei nach /usr/local/bin kopiert und einen systemd-Service anlegt. Eine manuelle Installation im Home-Verzeichnis ohne sudo ist möglich, dann musst Du Ollama aber manuell starten.

Wie mache ich Ollama im Netzwerk erreichbar?

Setze OLLAMA_HOST auf 0.0.0.0:11434 in der systemd-Service-Datei und öffne den Port in Deiner Firewall. Beachte, dass Ollama dann von jedem Rechner im Netzwerk angesprochen werden kann.

Funktioniert Ollama mit AMD-Grafikkarten?

Ja, wenn ROCm installiert ist und die Grafikkarte von ROCm unterstützt wird. Nicht jede AMD-GPU ist kompatibel, ältere Modelle funktionieren unter Umständen nur auf der CPU.

Wie sehe ich, ob Ollama die GPU nutzt?

Starte ein Modell und führe in einem zweiten Terminal ollama ps aus. Die Spalte PROCESSOR zeigt an, ob die GPU genutzt wird. Alternativ zeigt nvidia-smi die GPU-Auslastung in Echtzeit.

Kann ich mehrere Modelle gleichzeitig laufen lassen?

Ja, Ollama kann mehrere Modelle gleichzeitig im Speicher halten. Bedenke aber, dass jedes Modell VRAM belegt. Wenn der VRAM nicht ausreicht, lagert Ollama Teile auf den System-RAM aus, was die Antworten verlangsamt.

Wie deinstalliere ich Ollama wieder?

Stoppe den Service, deaktiviere ihn und entferne die Dateien:

sudo systemctl stop ollama
sudo systemctl disable ollama
sudo rm /usr/local/bin/ollama
sudo rm /etc/systemd/system/ollama.service
sudo systemctl daemon-reload

Die Modelle unter /usr/share/ollama/.ollama/models kannst Du ebenfalls löschen, wenn Du sie nicht mehr brauchst.

Quellen und weiterführende Literatur

Offizielle Ollama-Dokumentation: ollama.com
Ollama GitHub-Repository: github.com/ollama/ollama
systemd-Dokumentation: systemd.io
Nvidia CUDA-Dokumentation: docs.nvidia.com/cuda
AMD ROCm-Dokumentation: rocmdocs.amd.com

Täglicher Artikel