Ollama auf dem Mac: lokale KI mit MLX nutzen

Ein Sprachmodell, das komplett auf dem eigenen Mac läuft, hat drei Vorteile: Deine Texte verlassen den Rechner nicht, es kostet nichts pro Anfrage, und es funktioniert auch im Zug ohne Netz. Der einfachste Weg dorthin ist Ollama. Seit Version 0.19 vom März 2026 nutzt Ollama auf Macs mit Apple-Chip Apples eigenes Framework MLX und holt damit spürbar mehr Tempo aus dem gemeinsamen Arbeitsspeicher. Die eigentliche Frage ist deshalb weniger das Wie, sondern welches Modell zu Deinem Mac passt.

Stand dieser Anleitung ist Ollama 0.40.15 unter macOS 27. Die Befehle stammen aus der offiziellen Ollama-Dokumentation.

Was Du brauchst

Ollama läuft ab macOS Sonoma 14. Richtig Spaß macht es nur mit einem Apple-Chip (M1 oder neuer), weil Ollama dort die Grafikeinheit mitrechnen lässt. Auf alten Intel-Macs rechnet nur der Prozessor, und das ist für den Alltag zu langsam.

Entscheidend ist der Arbeitsspeicher, denn das Modell muss komplett hineinpassen. Wie viel Dein Mac hat, siehst Du unter Apple-Menü > Über diesen Mac in der Zeile Speicher. Plane außerdem freien Platz auf der SSD ein: Ein einzelnes Modell belegt zwischen etwa 2 und über 40 GB.

Ollama installieren

1. Lade die App von der offiziellen Download-Seite herunter.
2. Öffne die Datei Ollama.dmg und zieh Ollama in den Ordner Programme.
3. Starte Ollama aus dem Programme-Ordner. Beim ersten Start bietet die App an, das Kommandozeilenwerkzeug ollama einzurichten. Bestätige das mit Deinem Passwort.

Danach erscheint ein kleines Lama-Symbol in der Menüleiste: Ollama läuft im Hintergrund und wartet auf Anfragen. Ob alles geklappt hat, prüfst Du im Terminal:

ollama --version

Die Ausgabe nennt die installierte Version. Ollama aktualisiert sich künftig selbst und meldet neue Versionen über das Symbol in der Menüleiste.

Das erste Modell starten

Für den Einstieg eignet sich Gemma 4 von Google in der kleinsten Variante. Starte es mit:

ollama run gemma4:e2b

Beim ersten Aufruf lädt Ollama das Modell herunter, laut Dokumentation rund 7 GB. Danach landest Du in einem Chat direkt im Terminal: Tipp eine Frage ein und bestätige mit Enter. Mit /bye beendest Du den Chat wieder. Wer lieber in einem Fenster chattet, nutzt die Ollama-App selbst, die ein eigenes Chatfenster mitbringt.

Die wichtigsten Befehle für den Alltag:

Die Modelle liegen im versteckten Ordner ~/.ollama/models in Deinem Benutzerordner.

Welches Modell passt zu Deinem Mac?

macOS selbst und Deine offenen Programme brauchen ebenfalls Speicher. Als Faustregel sollte das Modell höchstens etwa zwei Drittel des Arbeitsspeichers belegen. Die Tabelle ist eine Orientierung auf Basis der Modellgrößen in der Ollama-Bibliothek, keine Garantie, denn längere Chats brauchen zusätzlich Speicher:

Mein Rat: Fang eine Stufe kleiner an, als die Tabelle erlaubt. Ein kleines Modell, das flüssig antwortet, benutzt Du im Alltag öfter als ein großes, bei dem Du auf jedes Wort wartest.

Prüfen, ob die Grafikeinheit mitrechnet

Starte ein Modell und öffne parallel ein zweites Terminalfenster mit:

ollama ps

In der Spalte PROCESSOR sollte 100% GPU stehen. Dann liegt das Modell komplett im schnellen Speicher und rechnet auf der Grafikeinheit des Apple-Chips. Steht dort eine Aufteilung wie 48%/52% CPU/GPU, ist das Modell zu groß für Deinen Mac: Es läuft, aber deutlich langsamer. Dann nimm eine kleinere Variante.

Wie schnell ein Modell antwortet, zeigt der Zusatz --verbose. Nach jeder Antwort steht dann unter anderem die eval rate in Token pro Sekunde. Alles ab etwa 20 Token pro Sekunde liest sich flüssig.

ollama run qwen3:8b --verbose

Längere Texte: die Kontextlänge

Wie viel Text ein Modell auf einmal überblickt, bestimmt die Kontextlänge. Ollama wählt sie automatisch passend zum Speicher, auf Macs mit weniger als 24 GB aber nur 4000 Token. Das reicht für einen Chat, nicht für ganze Dokumente oder Programmcode. Für lange Dokumente, Programmierwerkzeuge oder Agenten empfiehlt die Dokumentation zur Kontextlänge mindestens 64000 Token. Am einfachsten stellst Du das in den Einstellungen der Ollama-App mit dem Schieberegler ein. Bedenke: Mehr Kontext braucht mehr Arbeitsspeicher, auf einem 16-GB-Mac passt dann nur noch ein kleineres Modell.

Ollama aus eigenen Programmen nutzen

Ollama stellt im Hintergrund eine Schnittstelle unter http://localhost:11434 bereit. Darauf greifen Editoren, Notiz-Apps und eigene Skripte zu. Ein schneller Test im Terminal:

curl http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [{"role": "user", "content": "Was ist MLX?"}], "stream": false}'

Die Antwort kommt als JSON zurück, den Text findest Du im Feld content. Die Schnittstelle ist bewusst nur auf Deinem Mac erreichbar. Wenn Du Deine lokalen Modelle auch vom iPhone aus nutzen willst, zeigt LM Studio Locally: Lokale KI-Modelle vom iPhone nutzen einen Weg dafür. Eine komfortable Oberfläche für mehrere Modelle beschreibt Odysseus: Eigener KI-Workspace mit lokalen Modellen.

Über den Chat hinaus: mit Ollama programmieren

Der Chat im Terminal ist nur der Anfang. Spannend wird Ollama, wenn ein lokales Modell nicht nur antwortet, sondern selbst Dateien anlegt, Code ändert, Befehle ausführt und Fehler behebt, so wie Claude Code oder Codex mit den Cloud-Modellen. Solche Programme heißen Coding-Agenten. Ollama spricht inzwischen auch dieselbe Schnittstelle wie die Anthropic-API, und mit dem Befehl ollama launch startet es die bekanntesten Agenten gleich mit einem lokalen Modell. In der installierten Version 0.40.15 zeigt ollama launch --help unter anderem Claude Code, Codex, OpenCode, Cline, Copilot CLI und VS Code als unterstützte Integrationen.

Bevor Du loslegst, eine ehrliche Einordnung: Ein lokales Modell auf dem Mac ist kein Ersatz für Claude oder GPT in der Cloud. Für überschaubare Aufgaben funktioniert es gut, für große Umbauten über viele Dateien merkst Du den Abstand deutlich. Was das konkret heißt, steht weiter unten bei den Vor- und Nachteilen.

Was ein Modell zum Programmieren braucht

Ein Coding-Agent arbeitet mit Werkzeugen: Datei lesen, Datei schreiben, Befehl ausführen. Das Modell muss diese Werkzeuge gezielt aufrufen können, das nennt sich Tool Calling. Nicht jedes Modell kann das zuverlässig. In der Ollama-Bibliothek erkennst Du geeignete Modelle am Merkmal tools. Für den Mac eignen sich vor allem drei:

Die Spalte Arbeitsspeicher ist meine Faustregel, denn zum Modell kommen der Kontext, der Editor, der Browser und gegebenenfalls Docker. Auf einem Mac mit 16 GB passen diese Modelle nicht sinnvoll. Dort bleiben nur kleine Modelle, mit denen Agenten oft scheitern, oder die Cloud-Modelle von Ollama, dazu gleich mehr.

Schritt 1: Den Kontext auf 64000 Token stellen

Das ist der wichtigste Handgriff und der häufigste Grund, warum lokale Agenten „dumm“ wirken. Laut Ollama-Dokumentation brauchen Coding-Werkzeuge mindestens 64000 Token Kontext. Mit den voreingestellten 4000 Token vergisst der Agent schon nach wenigen gelesenen Dateien, worum es ging.

Öffne die Einstellungen der Ollama-App und schieb den Regler für die Kontextlänge auf 64k. Danach startest Du ein Modell und prüfst mit ollama ps in der Spalte CONTEXT, ob der Wert übernommen wurde. In der Spalte PROCESSOR sollte weiterhin 100% GPU stehen. Steht dort jetzt ein CPU-Anteil, ist Modell plus Kontext zu groß für Deinen Speicher.

Schritt 2: Einen Coding-Agenten mit Ollama starten

Du hast drei gängige Agenten zur Wahl, alle laufen im Terminal und lassen sich mit einem Befehl an Ollama hängen.

OpenCode ist ein quelloffener Agent, der von Anfang an für viele verschiedene Modelle gebaut wurde. Er ist meine Empfehlung für den lokalen Einstieg. Installiere ihn und starte ihn mit Ollama:

curl -fsSL https://opencode.ai/install | bash
ollama launch opencode

ollama launch fragt nach dem Modell, trägt Ollama als Anbieter in die Konfiguration von OpenCode ein und startet den Agenten. Die Anleitung von Ollama zu OpenCode beschreibt auch die manuelle Konfiguration.

Claude Code kennst Du vielleicht schon mit den Claude-Modellen. Mit Ollama nutzt Du dieselbe Oberfläche, nur mit einem lokalen Modell:

ollama launch claude --model qwen3-coder:30b

Das funktioniert über die Anthropic-kompatible Schnittstelle von Ollama. Wichtig zu wissen: Anthropic selbst unterstützt den Betrieb von Claude Code mit fremden Modellen offiziell nicht, die Anbindung stammt von Ollama. Einige Funktionen wie die Websuche und das Zwischenspeichern von Prompts fehlen dabei. Wie Du Claude Code installierst, zeigt Anleitung: Claude Code auf dem Mac installieren & nutzen.

Codex von OpenAI startest Du auf dieselbe Weise mit ollama launch codex. Die Kombination passt besonders zu gpt-oss:20b, weil das Modell ebenfalls von OpenAI stammt.

Alle drei fragen Dich vor jeder Dateiänderung und jedem Befehl um Erlaubnis. Lies diese Abfragen anfangs aufmerksam, lokale Modelle schlagen öfter umständliche oder falsche Befehle vor als Claude in der Cloud.

Welchen Editor Du am Mac nehmen solltest

Den Agenten im Terminal kombinierst Du mit einem Editor, in dem Du den Code liest und die Änderungen prüfst. Viele Editoren bringen inzwischen auch eigene KI-Anbindungen mit. Das sind die realistischen Optionen am Mac:

Meine Empfehlung für Webprojekte: VS Code als Editor und OpenCode oder Claude Code im eingebauten Terminal von VS Code als Agent. So hast Du Code, Änderungen, Git und den Agenten in einem Fenster, und der Agent im Terminal kommt mit lokalen Modellen meist besser zurecht als die Agenten-Erweiterungen im Editor. Wer VS Code noch nicht eingerichtet hat, findet die Schritte in Mac für Entwickler einrichten: der Leitfaden für 2026.

Für die Ollama-Erweiterung im Copilot-Chat brauchst Du laut Ollama-Anleitung für VS Code VS Code 1.127 oder neuer. Die Modelle erscheinen dann im Modellwähler des Chats unter Ollama. In Zed trägst Du Ollama unter den LLM-Anbietern ein und setzt in den Einstellungen context_window auf mindestens 64000, wie es die Zed-Dokumentation beschreibt.

Ein Webprojekt mit Docker bauen lassen

So sieht ein typischer Ablauf aus, wenn Du eine kleine Web-App mit Datenbank vom Agenten bauen lässt:

1. Projektordner anlegen und Git starten. Leg einen leeren Ordner an, öffne ihn in VS Code und tippe im Terminal git init. So kannst Du jede Änderung des Agenten nachvollziehen und notfalls zurückdrehen.
2. Regeln für den Agenten aufschreiben. Leg eine Datei AGENTS.md an (Claude Code liest CLAUDE.md). Schreib hinein, welche Technik Du willst, zum Beispiel „Node.js mit Express, PostgreSQL, alles per Docker Compose, Ports 3000 und 5432“, und dass der Agent nach jeder Änderung docker compose up --build testen soll. Lokale Modelle halten sich an klare, kurze Regeln deutlich besser als an lange Prosa.
3. In kleinen Schritten arbeiten. Bitte nicht um „eine komplette Shop-Software“, sondern um ein Grundgerüst: Dockerfile, compose.yaml, eine Startseite und eine Tabelle in der Datenbank. Prüf das Ergebnis, committe es und gib dann die nächste Aufgabe.
4. Den Agenten testen lassen. Der Agent kann docker compose up --build selbst ausführen und Fehlermeldungen lesen. Genau darin sind Agenten stark: Fehler sehen, korrigieren, erneut starten.

Für Docker brauchst Du am Mac Docker Desktop. Bedenke dabei: Docker reserviert sich eigenen Arbeitsspeicher, der dem Modell dann fehlt. Auf einem Mac mit 32 GB solltest Du Docker in den Einstellungen auf 4 bis 6 GB begrenzen, damit qwen3-coder:30b weiter komplett auf der Grafikeinheit läuft.

Das Projekt zu GitHub pushen

Wenn Git, SSH-Schlüssel und das GitHub-Werkzeug gh eingerichtet sind, wie in Mac für Entwickler einrichten: der Leitfaden für 2026 beschrieben, legst Du das Repository bei GitHub direkt aus dem Projektordner an:

gh repo create meine-web-app --private --source=. --push

Der Befehl erstellt ein privates Repository namens meine-web-app, verknüpft es mit Deinem Ordner und lädt alle bisherigen Commits hoch. Danach reicht für jeden weiteren Stand ein git push, oder Du nutzt in VS Code die Ansicht Quellcodeverwaltung.

Zwei Dinge solltest Du vor dem ersten Push prüfen. Erstens: Steht eine Datei .gitignore im Projekt, die .env, node_modules und Datenbankdateien ausschließt? Lokale Modelle schreiben Passwörter gern direkt in den Code oder in die compose.yaml. Zweitens: Lies die Änderungen vor dem Commit selbst durch. Du kannst den Agenten zwar committen und pushen lassen, aber gerade bei lokalen Modellen lohnt der eigene Blick.

Vor- und Nachteile lokaler Modelle beim Vibe Coding

Mit Vibe Coding ist gemeint, einer KI in normaler Sprache zu sagen, was entstehen soll, und sie den Code weitgehend allein schreiben zu lassen. Mit Claude oder Codex in der Cloud funktioniert das inzwischen erstaunlich gut. Mit lokalen Modellen sieht die Bilanz so aus, wie sie Entwickler in Erfahrungsberichten und Tests immer wieder beschreiben:

Vorteile:

• Dein Code bleibt auf dem Mac. Für Firmenprojekte oder private Daten oft das entscheidende Argument.
• Keine Kosten pro Anfrage und keine Limits. Kein Abo, keine Sperre nach zu vielen Anfragen, der Agent darf beliebig oft probieren.
• Funktioniert offline, zum Beispiel unterwegs im Zug.

Nachteile:

• „Das Modell redet, aber ändert keine Dateien.“ Das häufigste Problem. Ursache ist fast immer ein Modell ohne zuverlässiges Tool Calling oder ein zu kleines Modell. Nimm eins der drei Modelle aus der Tabelle oben.
• Der Agent vergisst, was er tun sollte. Der Kontext steht noch auf 4000 Token. Stell ihn auf 64000, wie in Schritt 1 beschrieben.
• Lange Wartezeit vor der ersten Antwort. Bei großem Kontext muss der Mac erst alle eingelesenen Dateien verarbeiten, bevor das erste Wort kommt. Bei großen Projekten sind das schnell eine Minute und mehr.
• Schwächer bei großen Aufgaben. Kleine Funktionen, Fehlersuche und Grundgerüste klappen gut. Umbauten über viele Dateien, verzwickte Logik und Sicherheitsfragen gelingen Cloud-Modellen deutlich zuverlässiger.
• Schleifen. Kleinere Modelle wiederholen manchmal denselben fehlschlagenden Befehl. Brich dann ab, gib einen konkreten Hinweis und starte die Aufgabe neu.
• Speicherkonkurrenz. Modell, Docker, Browser und Editor teilen sich den Arbeitsspeicher. Unter 32 GB wird es eng.

Ein guter Mittelweg sind die Cloud-Modelle von Ollama. Sie tragen den Zusatz :cloud, etwa qwen3-coder:480b-cloud, und laufen auf den Servern von Ollama statt auf Deinem Mac. Dafür meldest Du Dich einmal mit ollama signin an. Laut Ollama-Dokumentation werden die Anfragen dort nur zur Beantwortung verarbeitet und nicht zum Training genutzt, Dein Code verlässt aber natürlich den Mac. Viele arbeiten deshalb gemischt: lokale Modelle für kleine Aufgaben und vertrauliche Projekte, ein großes Cloud-Modell für die schweren Brocken.

Typische Probleme

• Antworten kommen extrem langsam: ollama ps zeigt einen CPU-Anteil. Das Modell ist zu groß, nimm die nächstkleinere Variante oder schließ speicherhungrige Programme wie viele Browser-Tabs.
• „could not connect to a running Ollama instance“: Die App läuft nicht. Starte Ollama aus dem Programme-Ordner, dann ist das Lama in der Menüleiste wieder da.
• Die SSD läuft voll: ollama ls zeigt, welche Modelle wie viel Platz belegen. Lösch nicht mehr genutzte mit ollama rm.
• Das Modell erfindet Fakten: Lokale Modelle sind kleiner als Cloud-Modelle wie Claude oder ChatGPT und liegen bei Detailwissen öfter daneben. Für Zusammenfassen, Umformulieren und Brainstorming sind sie stark, für Faktenfragen solltest Du die Antwort prüfen.
• Claude Code meldet, das Modell sei nicht verfügbar: Starte Claude Code über ollama launch claude --model <modell> mit einem Modell, das Du vorher mit ollama pull geladen hast. Der Modellname muss genau so geschrieben sein wie in ollama ls.
• Zed oder eine Editor-Erweiterung vergisst den Code: Diese Programme schicken ihre eigene Kontextlänge an Ollama, oft nur 4096 Token. Erhöhe sie in den Einstellungen des Editors, die Einstellung in der Ollama-App allein reicht dann nicht.

Fazit

Mit Ollama läuft ein brauchbares Sprachmodell in zehn Minuten auf dem Mac, privat und ohne Kosten pro Anfrage. Wähl das Modell nach Deinem Arbeitsspeicher, prüf mit ollama ps, dass 100% GPU dasteht, und arbeite Dich dann eine Stufe nach oben, solange die Antworten flüssig kommen. Zum Programmieren stellst Du den Kontext auf 64000 Token, nimmst qwen3-coder:30b oder gpt-oss:20b und startest OpenCode oder Claude Code mit ollama launch. Für kleine Projekte und vertrauliche Daten ist das eine echte Alternative, für große Umbauten bleiben Claude und Codex in der Cloud vorerst überlegen.