Ollama Konfiguration: Alle Optionen und Einstellungen

Was dieser Artikel über Ollama Konfiguration behandelt

Welche Umgebungsvariablen Ollama bietet und wie Du sie setzt
Wie Du den Speicherort für Modelle änderst, damit Deine Festplatte nicht vollläuft
Wie Du Netzwerkzugriff von anderen Geräten erlaubst
Wie Du mit Modelfiles eigene Modellvarianten erstellst
Wie Du Performance über GPU-Layer, Parallelität und Kontextlänge optimierst

Einleitung: Ollama Konfiguration verständlich erklärt

Ollama läuft nach der Installation meistens sofort. Du lädst ein Modell herunter, stellst eine Frage, bekommst eine Antwort. Für erste Experimente reicht das völlig aus. Sobald Du aber ernsthaft mit lokalen Modellen arbeitest, stößt Du auf Fragen, die sich nur über die Konfiguration lösen lassen: Wo werden die Modelle gespeichert? Wie viel VRAM soll Ollama nutzen? Darf ein anderes Gerät im Netzwerk auf Ollama zugreifen? Wie halte ich ein Modell länger im RAM?

Dieser Artikel führt Dich durch alle wichtigen Einstellungen. Du lernst, welche Umgebungsvariablen es gibt, wie Du Modelfiles schreibst und wie Du Ollama auf Linux, Windows und macOS konfigurierst. Alles Schritt für Schritt, mit Beispielen, die Du direkt übernehmen kannst.

Wenn Du noch nicht installiert hast, lies zuerst die Ollama Übersicht und die Installationsanleitung.

Warum brauche ich Konfiguration?

Stell Dir vor, Du hast Ollama auf Windows installiert und lädst ein paar Modelle herunter. Ein 7B-Modell belegt rund 4,5 GB, ein 13B-Modell gut 7 GB, und bei größeren Modellen wird es schnell eng. Standardmäßig speichert Ollama alles auf der Systemfestplatte, meist Laufwerk C:. Nach drei oder vier Modellen ist Deine SSD voll, und Windows warnt vor zu wenig Speicherplatz.

Das ist kein Bug, sondern die Standardeinstellung. Ollama weiß nicht, dass Du eine große Datenfestplatte in D: hast. Du musst Ollama über die Umgebungsvariable OLLAMA_MODELS mitteilen, wohin die Modelle sollen.

Ein anderes Beispiel: Du möchtest Ollama von einem zweiten PC oder von Deinem Handy im WLAN ansprechen. Standardmäßig lauscht Ollama nur auf localhost, akzeptiert also keine Verbindungen von außen. Erst mit OLLAMA_HOST=0.0.0.0 und den passenden OLLAMA_ORIGINS öffnest Du den Dienst für Dein Netzwerk. Mehr dazu im Artikel Netzwerkzugriff.

Oder Du arbeitest mit langen Dokumenten und brauchst einen größeren Kontext. Standardmäßig nutzt Ollama 2048 Token als Context Window. Für längere Texte musst Du den Wert über ein Modelfile oder einen API-Parameter erhöhen. Mehr zur Kontextlänge findest Du im Grundlagenartikel Kontextlänge.

Konfiguration ist also kein optionales Extra, sondern die Voraussetzung, um Ollama an Deine Hardware und Deine Nutzung anzupassen.

Ollama Konfiguration kurz erklärt

Ollama wird hauptsächlich über Umgebungsvariablen konfiguriert. Das sind Schlüssel-Wert-Paare, die Ollama beim Start liest. Du setzt sie im Betriebssystem, und Ollama übernimmt die Werte beim nächsten Start.

Zusätzlich gibt es Modelfiles. Das sind Textdateien, in denen Du beschreibst, wie sich ein bestimmtes Modell verhalten soll: welcher System Prompt gilt, welche Parameter für Temperatur oder Kontextlänge gelten, und ob das Modell auf einem anderen Modell aufbaut.

Die wichtigsten Umgebungsvariablen heißen OLLAMA_MODELS (Speicherort), OLLAMA_HOST (Netzwerkadresse), OLLAMA_ORIGINS (erlaubte Quellen), OLLAMA_GPU_LAYERS (GPU-Layer), OLLAMA_NUM_PARALLEL (parallele Anfragen) und OLLAMA_MAX_LOADED_MODELS (gleichzeitig geladene Modelle).

Für wen ist diese Konfiguration gedacht?

Dieser Artikel richtet sich an Anfängerinnen und Anfänger, die Ollama installiert haben und jetzt mehr Kontrolle wollen. Du brauchst keine Programmierkenntnisse, nur grundlegende Vertrautheit mit Deinem Betriebssystem. Wo Du eine Umgebungsvariable setzt, wird für Linux, Windows und macOS jeweils einzeln gezeigt.

Wenn Du Ollama produktiv einsetzt, etwa als Backend für eine Chat-Anwendung im LAN, findest Du hier auch die fortgeschrittenen Themen wie Performance-Tuning und systemd-Konfiguration.

Wichtige Begriffe rund um Ollama Konfiguration

Begriff	Bedeutung
Umgebungsvariable	Ein Schlüssel-Wert-Paar im Betriebssystem, das Ollama beim Start ausliest, z. B. `OLLAMA_MODELS=/data/ollama`
Modelfile	Eine Textdatei, die beschreibt, wie ein Modell konfiguriert ist: Basismodell, System Prompt, Parameter
`OLLAMA_MODELS`	Legt fest, in welchem Verzeichnis Ollama Modelle speichert und lädt
`OLLAMA_HOST`	Bestimmt, auf welcher Adresse und welchem Port Ollama lauscht, z. B. `0.0.0.0:11434`
`OLLAMA_ORIGINS`	Liste der erlaubten Origins für CORS, wichtig bei Web-Frontends
`OLLAMA_GPU_LAYERS`	Anzahl der Modell-Layer, die auf die GPU ausgelagert werden
`OLLAMA_NUM_PARALLEL`	Anzahl der Anfragen, die Ollama gleichzeitig verarbeitet
`OLLAMA_MAX_LOADED_MODELS`	Maximale Anzahl Modelle, die gleichzeitig im Speicher bleiben
Context Window	Anzahl Token, die das Modell als Kontext berücksichtigen kann
System Prompt	Eine Anweisung, die das Modell am Anfang erhält und die sein Verhalten steuert

Umgebungsvariablen im Überblick

Ollama kennt eine Reihe von Umgebungsvariablen. Hier sind die wichtigsten mit Beschreibung und Standardwert:

Variable	Beschreibung	Standard
`OLLAMA_HOST`	Adresse und Port, auf denen Ollama lauscht	`127.0.0.1:11434`
`OLLAMA_MODELS`	Verzeichnis für Modell-Speicherung	`~/.ollama/models`
`OLLAMA_ORIGINS`	Erlaubte Origins für CORS-Anfragen	`*` (in neueren Versionen)
`OLLAMA_GPU_LAYERS`	Layer, die auf die GPU ausgelagert werden	Automatisch, je nach VRAM
`OLLAMA_NUM_PARALLEL`	Anzahl paralleler Anfragen pro Modell	`1`
`OLLAMA_MAX_LOADED_MODELS`	Maximal gleichzeitig geladene Modelle	`1` (bei begrenztem RAM)
`OLLAMA_KEEP_ALIVE`	Wie lange ein Modell nach der letzten Anfrage im RAM bleibt	`5m`
`OLLAMA_NUM_CTX`	Standard-Kontextlänge in Token	`2048`
`OLLAMA_FLASH_ATTENTION`	Aktiviert Flash Attention, spart VRAM	`0` (deaktiviert)
`OLLAMA_KV_CACHE_TYPE`	Datentyp für KV-Cache, z. B. `q8_0` für weniger VRAM	Standard-Datentyp
`OLLAMA_DEBUG`	Aktiviert detaillierte Logs	`0`
`OLLAMA_LLM_LIBRARY`	Erzwingt eine bestimmte Backend-Bibliothek	Automatisch

Nicht jede Variable musst Du setzen. Die meisten Standardwerte sind sinnvoll. Die folgenden Abschnitte zeigen, wann Du welche Variable anpassen solltest.

Modellspeicher ändern (OLLAMA_MODELS)

Die häufigste Konfiguration ist das Ändern des Speicherorts für Modelle. Standardmäßig legt Ollama Modelle im Home-Verzeichnis ab. Auf Windows ist das oft C:\Users\DeinName\.ollama\models, auf Linux ~/.ollama/models, auf macOS ~/.ollama/models.

Wenn Deine Systemfestplatte klein ist, willst Du die Modelle auf eine andere Festplatte verschieben.

Linux

Setze die Variable dauerhaft in Deiner Shell-Konfiguration:

echo 'export OLLAMA_MODELS=/data/ollama/models' >> ~/.bashrc
source ~/.bashrc

Wenn Du Ollama als systemd-Service betreibst, siehe den Abschnitt Konfiguration unter Linux weiter unten.

Windows

Drücke die Windows-Taste und suche nach “Umgebungsvariablen”
Klicke auf “Systemumgebungsvariablen bearbeiten”
Klicke auf “Umgebungsvariablen”
Unter “Benutzervariablen” klicke auf “Neu”
Name: OLLAMA_MODELS, Wert: D:\ollama\models
Bestätige mit OK
Starte Ollama neu, am besten über den Task-Manager oder einen Neustart

macOS

Auf macOS setzt Du die Variable in Deiner Shell-Konfiguration, wenn Du Ollama im Terminal startest:

echo 'export OLLAMA_MODELS=/Volumes/Data/ollama/models' >> ~/.zshrc
source ~/.zshrc

Wenn Du die Ollama-App nutzt, starte sie aus dem Terminal mit der gesetzten Variable, oder nutze launchctl setenv:

launchctl setenv OLLAMA_MODELS /Volumes/Data/ollama/models

Danach starte die Ollama-App neu. Verschiebe bestehende Modelle aus dem alten Verzeichnis in das neue, damit Du sie nicht neu herunterladen musst.

Netzwerk konfigurieren (OLLAMA_HOST, OLLAMA_ORIGINS)

Standardmäßig lauscht Ollama auf 127.0.0.1:11434, also nur auf dem lokalen Rechner. Wenn Du Ollama von einem anderen Gerät im Netzwerk ansprechen willst, musst Du die Bind-Adresse ändern.

Setze OLLAMA_HOST auf 0.0.0.0:11434, damit Ollama auf allen Netzwerkschnittstellen lauscht:

export OLLAMA_HOST=0.0.0.0:11434

Danach erreichst Du Ollama von einem anderen Gerät über die IP-Adresse Deines Rechners, zum Beispiel http://192.168.1.100:11434.

Wenn Du ein Web-Frontend wie Open WebUI nutzt, das im Browser läuft und Anfragen an Ollama schickt, brauchst Du zusätzlich OLLAMA_ORIGINS. Browser senden einen Origin-Header, und Ollama prüft, ob diese Origin erlaubt ist:

export OLLAMA_ORIGINS=http://192.168.1.50:3000,http://localhost:3000

Trenne mehrere Origins mit Kommas. Ausführliche Informationen findest Du im Artikel Netzwerkzugriff.

Achtung: Wenn Du Ollama ins Internet freigibst, kann jeder Deine Modelle nutzen. Beschränke den Zugriff auf Dein lokales Netzwerk oder setze einen Reverse Proxy mit Authentifizierung davor.

GPU-Layer kontrollieren

Ollama entscheidet automatisch, wie viele Layer eines Modells auf die GPU ausgelagert werden. Das hängt vom verfügbaren VRAM ab. Manchmal willst Du aber manuell eingreifen, etwa wenn Ollama zu viel VRAM belegt und andere Programme darunter leiden.

Mit OLLAMA_GPU_LAYERS legst Du fest, wie viele Layer auf die GPU gehen. Der Rest läuft auf der CPU:

export OLLAMA_GPU_LAYERS=20

Ein höherer Wert bedeutet mehr Layer auf der GPU und damit schnellere Antworten, aber auch mehr VRAM-Verbrauch. Ein niedrigerer Wert schont den VRAM, macht die Antworten aber langsamer.

Du kannst den Wert auch pro Modell über ein Modelfile setzen, siehe den nächsten Abschnitt. Mehr Hintergrund zum Thema GPU-Offloading findest Du im Artikel GPU-Offloading.

Modelfiles: Eigene Modelle erstellen

Modelfiles sind Textdateien, in denen Du beschreibst, wie ein Modell konfiguriert ist. Du kannst einen System Prompt festlegen, Parameter wie Temperatur und Kontextlänge setzen, und auf einem bestehenden Modell aufbauen.

Aufbau eines Modelfiles

Ein Modelfile besteht aus Anweisungen, eine pro Zeile. Die wichtigsten sind:

FROM: Das Basismodell, auf dem Dein Modell aufbaut
SYSTEM: Der System Prompt, der das Modellverhalten steuert
PARAMETER: Modellparameter wie Temperatur, Kontextlänge, Top-K
TEMPLATE: Das Prompt-Template, wie Eingaben formatiert werden

Ein einfaches Beispiel

Erstelle eine Datei namens Modelfile:

FROM llama3.1:8b

SYSTEM "Du bist ein hilfreicher Assistent, der auf Deutsch antwortet. Du erklärst Dinge einfach und verständlich."

PARAMETER temperature 0.7
PARAMETER num_ctx 4096
PARAMETER top_p 0.9

Erstelle das Modell mit:

ollama create mein-assistent -f Modelfile

Danach startest Du es wie jedes andere Modell:

ollama run mein-assistent

Parameter im Überblick

Parameter	Bedeutung	Typischer Wert
`temperature`	Steuerung der Kreativität, niedriger = deterministischer	`0.7` bis `0.9`
`num_ctx`	Kontextlänge in Token	`2048` bis `8192`
`top_p`	Nucleus Sampling, begrenzt die Auswahlwahrscheinlichkeit	`0.9`
`top_k`	Begrenzt Auswahl auf die k wahrscheinlichsten Token	`40`
`repeat_penalty`	Bestraft Wiederholungen	`1.1`
`num_gpu`	Anzahl GPU-Layer für dieses Modell	Automatisch oder z. B. `20`
`stop`	Sequenzen, bei denen das Modell stoppt	z. B. `"\nUser:"`

Modelfiles sind der einfachste Weg, um ein Modell an Deinen Anwendungsfall anzupassen, ohne das Basismodell zu verändern. Mehr zum Verwalten von Modellen findest Du im Artikel Modelle verwalten.

Performance-Tuning

Wenn Du Ollama intensiver nutzt, etwa als Backend für mehrere Nutzer oder Anwendungen, kommen Performance-Fragen auf. Diese Variablen helfen Dir dabei.

OLLAMA_NUM_PARALLEL

Standardmäßig verarbeitet Ollama eine Anfrage pro Modell gleichzeitig. Wenn Du mehrere Anfragen parallel bearbeiten willst, erhöhe den Wert:

export OLLAMA_NUM_PARALLEL=2

Das bedeutet, dass Ollama zwei Anfragen gleichzeitig verarbeitet. Das kostet mehr VRAM, weil der KV-Cache für beide Anfragen vorgehalten wird. Prüfe, ob Dein VRAM ausreicht.

OLLAMA_MAX_LOADED_MODELS

Diese Variable legt fest, wie viele Modelle gleichzeitig im Speicher bleiben. Standard ist oft 1, was bedeutet, dass Ollama ein Modell entlädt, bevor es das nächste lädt. Wenn Du häufig zwischen Modellen wechselst, erhöhe den Wert:

export OLLAMA_MAX_LOADED_MODELS=2

Das kostet RAM und VRAM, weil beide Modelle gleichzeitig vorgehalten werden. Nutze das nur, wenn Du genug Speicher hast.

Kontextlänge anpassen

Die Kontextlänge bestimmt, wie viele Token das Modell als Verlauf berücksichtigt. Mehr Kontext bedeutet, dass Du längere Dokumente oder Gespräche verarbeiten kannst, kostet aber mehr VRAM. Setze die Kontextlänge über ein Modelfile mit PARAMETER num_ctx 8192, oder über die API mit dem Parameter num_ctx.

Hintergründe zur Kontextlänge und zum VRAM-Verbrauch findest Du im Artikel Kontextlänge.

keep_alive steuern

Mit OLLAMA_KEEP_ALIVE legst Du fest, wie lange ein Modell nach der letzten Anfrage im RAM bleibt. Standard ist 5m, also fünf Minuten. Wenn Du häufig Anfragen stellst, kannst Du den Wert erhöhen, um Ladezeiten zu sparen:

export OLLAMA_KEEP_ALIVE=30m

Wenn Du RAM sparen willst, setze den Wert niedriger oder auf 0, damit das Modell sofort entladen wird.

Flash Attention

Mit OLLAMA_FLASH_ATTENTION=1 aktivierst Du Flash Attention. Das kann den VRAM-Verbrauch bei langen Kontexten reduzieren und die Geschwindigkeit erhöhen. Nicht alle Modelle unterstützen es, probiere es aus und vergleiche.

Konfiguration unter Linux (systemd)

Unter Linux läuft Ollama meist als systemd-Service. Umgebungsvariablen setzt Du in der Service-Datei.

Öffne die Service-Datei:

sudo systemctl edit ollama.service

Trage die Variablen im Override ein:

[Service]
Environment="OLLAMA_MODELS=/data/ollama/models"
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_ORIGINS=http://192.168.1.50:3000"
Environment="OLLAMA_NUM_PARALLEL=2"

Speichere und lade systemd neu:

sudo systemctl daemon-reload
sudo systemctl restart ollama

Prüfe, ob die Variablen aktiv sind:

systemctl show ollama --property=Environment

Diese Methode ist dauerhaft und übersteht Neustarts. Ändere nicht die ursprüngliche Service-Datei, sondern nutze immer systemctl edit, damit Deine Änderungen bei Updates nicht verloren gehen.

Konfiguration unter Windows

Unter Windows nutzt Du die grafische Oberfläche für Umgebungsvariablen.

Drücke Windows-Taste, tippe “Umgebungsvariablen”
Wähle “Systemumgebungsvariablen bearbeiten”
Klicke auf “Umgebungsvariablen”
Unter “Benutzervariablen” klicke “Neu”
Trage Name und Wert ein, zum Beispiel:
- Name: OLLAMA_HOST, Wert: 0.0.0.0:11434
- Name: OLLAMA_MODELS, Wert: D:\ollama\models
Bestätige mit OK
Beende Ollama über den System-Tray (rechts unten in der Taskleiste)
Starte Ollama neu

Umgebungsvariablen gelten nach dem Neustart von Ollama. Wenn Du Ollama als Windows-Service betreibst, setze die Variablen unter “Systemvariablen” statt “Benutzervariablen”, damit der Service sie findet.

Konfiguration unter macOS

Auf macOS hängt die Methode davon ab, wie Du Ollama startest.

Ollama-App

Für die grafische App nutze launchctl setenv:

launchctl setenv OLLAMA_MODELS /Volumes/Data/ollama/models
launchctl setenv OLLAMA_HOST 0.0.0.0:11434

Starte die Ollama-App neu. Diese Variablen gelten bis zum nächsten Neustart. Für eine dauerhafte Lösung lege eine plist-Datei in ~/Library/LaunchAgents/ an.

Terminal

Wenn Du Ollama im Terminal startest, setze die Variablen in Deiner Shell-Konfiguration:

echo 'export OLLAMA_HOST=0.0.0.0:11434' >> ~/.zshrc
source ~/.zshrc

Danach starte Ollama mit ollama serve im Terminal.

Typische Stolpersteine bei der Konfiguration

Variablen werden nicht übernommen: Du musst Ollama komplett neu starten, nicht nur ein Modell neu laden. Unter Linux mit systemd: sudo systemctl restart ollama. Unter Windows: Ollama im System-Tray beenden und neu starten.
Modelle nach Speicherort-Wechsel verschwunden: Wenn Du OLLAMA_MODELS änderst, kennt Ollama die alten Modelle nicht mehr. Verschiebe den Inhalt des alten Verzeichnisses in das neue, oder lade die Modelle neu herunter.
CORS-Fehler im Browser: Wenn ein Web-Frontend Ollama aufruft und Fehler wie “CORS policy” auftauchen, fehlt die Origin in OLLAMA_ORIGINS. Trage die Adresse des Frontends ein, inklusive Port.
Zu wenig VRAM bei großem Kontext: Eine Kontextlänge von 8192 Token braucht deutlich mehr VRAM als 2048. Wenn Ollama abstürzt oder extrem langsam wird, reduziere num_ctx oder aktiviere Flash Attention.
Port-Konflikte: Wenn Port 11434 schon belegt ist, startet Ollama nicht. Ändere den Port über OLLAMA_HOST=0.0.0.0:11435 oder finde und beende das Programm, das den Port blockiert.
systemd-Override wird ignoriert: Prüfe mit systemctl show ollama --property=Environment, ob die Variablen wirklich geladen sind. Ein fehlendes sudo systemctl daemon-reload ist oft die Ursache.
Sicherheit bei Netzwerkfreigabe: OLLAMA_HOST=0.0.0.0 öffnet Ollama für alle Geräte im Netzwerk. Ohne Authentifizierung kann jeder Deine Modelle nutzen. Setze einen Reverse Proxy mit Passwortschutz davor, oder beschränke den Zugriff über eine Firewall.
Umgebungsvariablen unter Windows im falschen Bereich: Wenn Ollama als Service läuft, müssen die Variablen unter “Systemvariablen” stehen, nicht unter “Benutzervariablen”. Sonst findet der Service sie nicht.

Weitere Hilfe bei Problemen findest Du im Artikel Fehlerbehebung.

Hardware, Kosten und Sicherheit bei der Konfiguration

Die Konfiguration hängt stark von Deiner Hardware ab. Wer viel VRAM hat, kann mehr Layer auf die GPU auslagern, größere Kontexte nutzen und mehrere Modelle gleichzeitig laden. Wer wenig VRAM hat, muss Kompromisse eingehen.

VRAM und Layer

Ein 8B-Modell mit 4-Bit-Quantisierung braucht rund 5 GB VRAM für die Gewichte. Der KV-Cache für den Kontext kommt dazu. Bei 4096 Token Kontext sind das weitere 1 bis 2 GB, bei 8192 Token entsprechend mehr. Mehr zur Quantisierung und wie sie den Speicherbedarf reduziert, findest Du im Artikel Quantisierung.

RAM und CPU

Wenn nicht alle Layer auf die GPU passen, läuft der Rest auf der CPU. Das ist langsamer, funktioniert aber. Für CPU-only-Systeme wähle kleinere Modelle und kurze Kontexte.

Kosten

Ollama selbst ist kostenlos und Open Source. Kosten entstehen nur durch Hardware: eine GPU mit genug VRAM, ausreichend RAM und Speicherplatz für Modelle. Wenn Du Ollama nur ausprobierst, reicht ein normaler PC. Für ernsthafte Nutzung mit großen Modellen ist eine dedizierte GPU sinnvoll. Mehr dazu im Artikel LLM lokal betreiben.

Sicherheit

Wenn Du Ollama nur lokal nutzt, gibt es keine Sicherheitsbedenke. Sobald Du Netzwerkzugriff erlaubst, solltest Du Ollama nicht direkt ins Internet freigeben. Nutze einen Reverse Proxy mit Authentifizierung, etwa Nginx oder Caddy, und beschränke den Zugriff auf Dein LAN. Setze OLLAMA_ORIGINS so restriktiv wie möglich.

FAQ: Ollama Konfiguration - Typische Fragen

Wo speichert Ollama standardmäßig Modelle?

Im Home-Verzeichnis unter ~/.ollama/models auf Linux und macOS, unter C:\Users\DeinName\.ollama\models auf Windows. Du änderst den Ort mit OLLAMA_MODELS.

Wie ändere ich den Port von Ollama?

Setze OLLAMA_HOST=127.0.0.1:11435, um Port 11435 zu nutzen. Starte Ollama danach neu.

Was ist ein Modelfile?

Eine Textdatei, in der Du festlegst, auf welchem Basismodell Dein Modell aufbaut, welcher System Prompt gilt und welche Parameter gelten. Du erstellst es mit ollama create.

Wie erlaube ich Zugriff aus dem Netzwerk?

Setze OLLAMA_HOST=0.0.0.0:11434, damit Ollama auf allen Netzwerkschnittstellen lauscht. Setze zusätzlich OLLAMA_ORIGINS für CORS, wenn Du ein Web-Frontend nutzt.

Wie erhöhe ich die Kontextlänge?

Entweder über ein Modelfile mit PARAMETER num_ctx 8192, oder über die API mit dem Parameter num_ctx in den Optionen. Mehr Kontext braucht mehr VRAM.

Was macht OLLAMA_KEEP_ALIVE?

Es bestimmt, wie lange ein Modell nach der letzten Anfrage im RAM bleibt. Standard ist fünf Minuten. Höhere Werte sparen Ladezeit, kosten aber RAM.

Wie sehe ich, welche Variablen aktiv sind?

Unter Linux mit systemd: systemctl show ollama --property=Environment. Unter Windows und macOS prüfe die Umgebungsvariablen in den Systemeinstellungen oder mit echo $OLLAMA_HOST im Terminal.

Was ist Flash Attention?

Eine Technik, die den VRAM-Verbrauch bei langen Kontexten reduziert und die Geschwindigkeit erhöht. Aktiviere es mit OLLAMA_FLASH_ATTENTION=1. Nicht alle Modelle unterstützen es.

Kann ich mehrere Modelle gleichzeitig laden?

Ja, mit OLLAMA_MAX_LOADED_MODELS=2 oder höher. Das kostet RAM und VRAM, weil beide Modelle vorgehalten werden.

Wie viele parallele Anfragen unterstützt Ollama?

Standardmäßig eine pro Modell. Mit OLLAMA_NUM_PARALLEL=2 oder höher verarbeitet Ollama mehrere Anfragen gleichzeitig. Der VRAM-Bedarf steigt, weil der KV-Cache für jede Anfrage vorgehalten wird.

Wie debugge ich Ollama?

Setze OLLAMA_DEBUG=1, um detaillierte Logs zu aktivieren. Unter Linux siehst Du die Logs mit journalctl -u ollama. Unter Windows und macOS in der Konsole, aus der Du Ollama startest.

Muss ich Ollama neu starten, nachdem ich eine Variable gesetzt habe?

Ja, Ollama liest Umgebungsvariablen nur beim Start. Ein Neustart des Dienstes oder der App ist erforderlich.

Quellen und weiterführende Literatur

Offizielle Ollama-Dokumentation: GitHub-Repository unter ollama/ollama
Ollama FAQ und Issues auf GitHub
Artikel GPU-Offloading auf BotServ.de
Artikel Kontextlänge auf BotServ.de
Artikel Quantisierung auf BotServ.de
Artikel LLM lokal betreiben auf BotServ.de

Täglicher Artikel