Zum Inhalt springen

So führen Sie LLMs auf dem Mac Mini M4 aus (Llama, Mistral, Phi)

Die Unified-Memory-Architektur von Apple Silicon macht den Mac Mini M4 zu einer der kostengünstigsten Plattformen, um große Sprachmodelle lokal auszuführen. Dieser Leitfaden behandelt Ollama, llama.cpp und MLX mit echten Benchmarks und praktischen Codebeispielen.

KI und Machine Learning 20 Min. Lesezeit Aktualisiert im Oktober 2026 Fortgeschritten

Warum der Mac Mini M4 für LLMs?

Der Mac Mini M4 eignet sich dank der Architektur von Apple Silicon in einzigartiger Weise für das Ausführen großer Sprachmodelle. Anders als bei herkömmlichen GPU-Servern, bei denen der VRAM die Modellgröße begrenzt, ermöglicht der Unified Memory des M4, dass CPU, GPU und Neural Engine denselben Speicherpool teilen. Das bedeutet: Ein Mac Mini mit 24 GB kann Modelle laden, die sonst eine teure GPU mit 24 GB VRAM erfordern würden.

Unified-Memory-Architektur

Anders als NVIDIA-GPUs mit separatem VRAM ermöglicht der Unified Memory des M4 der GPU den Zugriff auf den gesamten Arbeitsspeicher. Ein Mac Mini mit 24 GB verfügt effektiv über 24 GB „VRAM" zum Laden von Modellen, ohne den Engpass der PCI-E-Bandbreite.

Neural Engine

Die 16-Core-Neural-Engine des M4 liefert bis zu 38 TOPS an ML-Leistung. CoreML nutzt sie, um lokale Modelle zu beschleunigen, während Ollama, llama.cpp und MLX LLMs über Metal auf der GPU des M4 ausführen.

Energieeffizienz

Der Mac Mini M4 verbraucht bei typischer LLM-Inferenzlast nur 5-15 W, verglichen mit 300-450 W für eine NVIDIA A100. Das führt zu dramatisch niedrigeren Hosting-Kosten und erfordert keine spezielle Kühlung.

Kostengünstig

Ab 85 $/Monat (USD, exkl. Steuern) für einen dedizierten Mac Mini M4 mit 16 GB erhalten Sie eine planbare Preisgestaltung ohne API-Kosten pro Token. Führen Sie unbegrenzte Inferenzanfragen rund um die Uhr zu einem Bruchteil der GPU-Cloud-Preise aus.

Wichtige Erkenntnis: Für Inferenz-Workloads (nicht das Training) bietet der Mac Mini M4 das beste Preis-Leistungs-Verhältnis der Branche. Sie erhalten dedizierte Hardware ohne störende Mitnutzer, ohne Abrechnung pro Token und mit der Speicherbandbreite von Apple Silicon von bis zu 120 GB/s.

Vergleich der LLM-Frameworks

Drei Frameworks dominieren das LLM-Ökosystem von Apple Silicon. Jedes hat je nach Anwendungsfall unterschiedliche Stärken.

Vergleich der LLM-Frameworks
Ollama llama.cpp MLX
Einfachheit der Einrichtung Sehr einfach Mittel Einfach
Metal-GPU-Unterstützung Ja (automatisch) Ja (Flag) Ja (nativ)
API-Server Integriert Integriert Integriert (mlx_lm.server)
Modellformat GGUF (automatischer Download) GGUF SafeTensors / MLX
Leistung Gut Am besten für GGUF Am besten für Apple Silicon
Modellbibliothek Kuratiert (ollama.com) HuggingFace GGUF HuggingFace MLX
Sprache Go (CLI/API) C++ (CLI/API) Python
Am besten für Schnelle Bereitstellung, API-Serving Maximale Kontrolle, benutzerdefinierte Builds Python-ML-Pipelines, Forschung

Einrichtung mit Ollama

Ollama ist der einfachste Weg, um mit LLMs auf dem Mac Mini M4 zu beginnen. Es übernimmt den Modell-Download, die Quantisierung und das API-Serving mit einer einzigen Binärdatei.

Schritt 1: Ollama installieren

# Install Ollama with Homebrew
# (or download the macOS app from ollama.com, which starts the server for you)
brew install ollama

# Start the server and leave it running (Step 6 starts it automatically)
ollama serve

# In a second terminal, verify installation
ollama --version

Schritt 2: Modelle herunterladen

# Download Llama 3 8B (4.7GB, fits 16GB RAM)
ollama pull llama3:8b

# Download Mistral 7B (4.1GB)
ollama pull mistral:7b

# Download Phi-3 Mini (2.3GB, great for constrained setups)
ollama pull phi3:mini

# Download Llama 3 70B (requires 48GB+ RAM)
ollama pull llama3:70b

# List downloaded models
ollama list
# NAME            SIZE     MODIFIED
# llama3:8b       4.7 GB   2 minutes ago
# mistral:7b      4.1 GB   5 minutes ago
# phi3:mini       2.3 GB   8 minutes ago

Schritt 3: Interaktiven Chat ausführen

# Start an interactive chat session
ollama run llama3:8b

# Example interaction:
# >>> What is the capital of France?
# The capital of France is Paris. It is the largest city in France
# and serves as the country's political, economic, and cultural center.

Schritt 4: Als API bereitstellen

Ollama startet automatisch einen REST-API-Server auf Port 11434. Sie können ihn von jeder Anwendung aus über die OpenAI-kompatible API abfragen.

# The Ollama server from Step 1 listens on localhost:11434

# Query using curl (OpenAI-compatible endpoint)
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3:8b",
    "messages": [
      {"role": "system", "content": "You are a helpful coding assistant."},
      {"role": "user", "content": "Write a Python function to calculate fibonacci numbers."}
    ],
    "temperature": 0.7,
    "max_tokens": 500
  }'

# Native Ollama API endpoint
curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama3:8b",
    "prompt": "Explain quantum computing in 3 sentences.",
    "stream": false
  }'

Schritt 5: Aus Python verwenden

# pip install openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama doesn't require an API key
)

response = client.chat.completions.create(
    model="llama3:8b",
    messages=[
        {"role": "system", "content": "You are a senior Python developer."},
        {"role": "user", "content": "Write a FastAPI endpoint for user registration."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

Schritt 6: Ollama als Hintergrunddienst ausführen

# Create a LaunchAgent: Ollama starts with your user session and restarts
# if it crashes (enable automatic login so it also returns after a reboot)
# (Homebrew on Apple Silicon installs ollama in /opt/homebrew/bin; check with: which ollama)
cat <<EOF > ~/Library/LaunchAgents/com.ollama.server.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.ollama.server</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/homebrew/bin/ollama</string>
        <string>serve</string>
    </array>
    <key>EnvironmentVariables</key>
    <dict>
        <key>OLLAMA_HOST</key>
        <string>127.0.0.1:11434</string>
    </dict>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>
EOF

# First stop the server you started by hand in Step 1 (Ctrl+C in its terminal):
# the service needs port 11434

# Load the service
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# Verify it's running
curl http://localhost:11434/api/tags

Einrichtung mit llama.cpp

llama.cpp bietet Ihnen maximale Kontrolle über die Inferenzparameter und liefert dank seines handoptimierten Metal-Backends oft die beste reine Leistung auf Apple Silicon.

Schritt 1: Klonen und mit Metal erstellen

# Install dependencies
brew install cmake

# Clone the repository
git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

# Build (Metal GPU acceleration is enabled by default on macOS)
cmake -B build
cmake --build build --config Release -j

# The binaries are in ./build/bin
./build/bin/llama-cli --version

Schritt 2: GGUF-Modelle herunterladen

# Install the Hugging Face CLI (hf) for easy downloads
pip install -U huggingface_hub

# Download Llama 3 8B Instruct Q4_K_M (best quality/speed balance)
hf download \
  bartowski/Meta-Llama-3-8B-Instruct-GGUF \
  Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
  --local-dir ./models

# Download Mistral 7B Q4_K_M
hf download \
  TheBloke/Mistral-7B-Instruct-v0.2-GGUF \
  mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  --local-dir ./models

# Download Phi-3 Mini Q4
hf download \
  microsoft/Phi-3-mini-4k-instruct-gguf \
  Phi-3-mini-4k-instruct-q4.gguf \
  --local-dir ./models

Schritt 3: Inferenz ausführen

# Run Llama 3 8B with Metal GPU offloading (all layers)
./build/bin/llama-cli \
  -m ./models/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
  -ngl 99 \
  -c 4096 \
  -t 8 \
  --temp 0.7 \
  -p "Explain how transformers work in machine learning:"

# Key flags:
# -ngl 99     : Offload all layers to Metal GPU
# -c 4096     : Context window size
# -t 8        : Number of CPU threads (M4 has 10 cores)
# --temp 0.7  : Temperature for sampling

Schritt 4: Den API-Server starten

# Start OpenAI-compatible API server
./build/bin/llama-server \
  -m ./models/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
  -ngl 99 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080 \
  --parallel 4

# Test the API
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Einrichtung mit MLX

MLX ist Apples eigenes Framework für maschinelles Lernen, das speziell für Apple Silicon entwickelt wurde. Es ist auf Unified Memory ausgelegt und läuft auf der CPU und der GPU des M4, ideal für Python-basierte ML-Workflows.

Schritt 1: MLX installieren

# Create a virtual environment
python3 -m venv ~/mlx-env
source ~/mlx-env/bin/activate

# Install MLX and the LLM package
pip install mlx mlx-lm

# Verify installation
python3 -c "import mlx.core as mx; print(mx.default_device())"
# Device(gpu, 0)

Schritt 2: Inferenz mit MLX ausführen

# Run Llama 3 8B using mlx-lm CLI
mlx_lm.generate \
  --model mlx-community/Meta-Llama-3-8B-Instruct-4bit \
  --prompt "Write a Python decorator for rate limiting:" \
  --max-tokens 500 \
  --temp 0.7

# Run Mistral 7B
mlx_lm.generate \
  --model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
  --prompt "Explain microservices architecture:" \
  --max-tokens 500

Schritt 3: Python-Integration

from mlx_lm import load, generate, stream_generate
from mlx_lm.sample_utils import make_sampler

# Load the model (downloads on first run)
model, tokenizer = load("mlx-community/Meta-Llama-3-8B-Instruct-4bit")

# Sampling settings are passed as a sampler object
sampler = make_sampler(temp=0.7, top_p=0.9)

# Generate text
prompt = "Write a bash script to monitor disk usage and send alerts:"
response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=500,
    sampler=sampler
)
print(response)

# Streaming generation: each chunk is a response object with .text
for chunk in stream_generate(
    model, tokenizer,
    prompt="Explain Docker networking:",
    max_tokens=300
):
    print(chunk.text, end="", flush=True)

Schritt 4: Eine einfache API mit MLX erstellen

# pip install fastapi uvicorn mlx-lm
# (mlx-lm also ships an OpenAI-compatible server: mlx_lm.server --model <repo>)
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mlx_lm import load, stream_generate
import json

app = FastAPI()
model, tokenizer = load("mlx-community/Meta-Llama-3-8B-Instruct-4bit")

@app.post("/v1/completions")
async def completions(request: dict):
    prompt = request.get("prompt", "")
    max_tokens = request.get("max_tokens", 256)

    response = ""
    for chunk in stream_generate(model, tokenizer, prompt=prompt, max_tokens=max_tokens):
        response += chunk.text

    return {"choices": [{"text": response}]}

@app.post("/v1/chat/completions")
async def chat(request: dict):
    messages = request.get("messages", [])
    prompt = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )

    response = ""
    for chunk in stream_generate(model, tokenizer, prompt=prompt, max_tokens=512):
        response += chunk.text

    return {
        "choices": [{
            "message": {"role": "assistant", "content": response}
        }]
    }

# Run: uvicorn server:app --host 0.0.0.0 --port 8000

Performance-Benchmarks

Praxisnahe Benchmarks, gemessen mit Ollama und Q4_K_M-Quantisierung. Alle Tests verwenden einen Prompt mit 512 Tokens, eine Generierung von 256 Tokens und die Standard-Sampling-Parameter.

Performance-Benchmarks
Hardware Modell Tokens/Sek. Zeit bis zum ersten Token Kosten/Monat
Mac Mini M4 16GB Llama 3 8B Q4 ~35 tok/s ~180ms $85
Mac Mini M4 16GB Mistral 7B Q4 ~38 tok/s ~160ms $85
Mac Mini M4 24GB Llama 3 13B Q4 ~22 tok/s ~320ms $129
Mac Mini M4 Pro 48GB Llama 3 70B Q4 ~12 tok/s ~850ms $299
RTX 4090 (cloud) Llama 3 8B Q4 ~120 tok/s ~50ms $500+

Preise von My Remote Mac: USD, exkl. Steuern, pro Monat.

Hinweis: Während NVIDIA-GPUs einen höheren reinen Durchsatz bieten, liefert der Mac Mini M4 hervorragende Tokens/Sekunde für interaktive Anwendungsfälle zu einem Bruchteil der Kosten. Bei 35 Tok/s wirken Antworten für Chat-Anwendungen augenblicklich. Der eigentliche Vorteil sind die Kosten: unbegrenzte Nutzung für 85 $/Monat (USD, exkl. Steuern) gegenüber Pay-per-Token-API-Preisen, die leicht 500 $/Monat überschreiten können.

Welche Modelle passen zu welcher Konfiguration?

Der entscheidende Faktor ist der Unified Memory. Mit Q4-Quantisierung verbrauchen Modelle etwa 0,5-0,6 GB pro Milliarde Parameter, zuzüglich Overhead für den Kontext und das Betriebssystem.

Welche Modelle passen zu welcher Konfiguration?
Modellgrößenbereich Beispielmodelle Preis/Monat
16 GB 7B - 13B (Q4) Llama 3 8B, Mistral 7B, Phi-3 Mini, Gemma 7B $85
24 GB 13B - 34B (Q4) Llama 3 13B, CodeLlama 34B, Yi 34B $129
48 GB 34B - 70B (Q4) Llama 3 70B, Mixtral 8x7B, DeepSeek 67B $299
64 GB+ 70B+ (Q4/Q6) Llama 3 70B Q6, Mixtral 8x22B, Command-R+ $449

Preise von My Remote Mac: USD, exkl. Steuern, pro Monat.

# Quick formula to estimate memory requirements:
# Memory needed = (Parameters in B * Bits per weight / 8) + context overhead
#
# Example: Llama 3 70B at Q4 quantization
# = (70 * 4 / 8) GB = 35 GB model weights
# + ~4 GB context/overhead
# = ~39 GB total → fits in 48GB Mac Mini M4 Pro
#
# Check current memory usage while running a model:
ollama ps
# NAME          SIZE     PROCESSOR    UNTIL
# llama3:8b     5.1 GB   100% GPU     4 minutes from now

Anwendungsfälle

Privater KI-Assistent

Führen Sie einen ChatGPT-ähnlichen Assistenten aus, der alle Daten auf Ihrem Server behält. Keine Daten verlassen Ihre Infrastruktur. Perfekt für den Umgang mit sensiblen Dokumenten, Kundendaten oder proprietärem Code.

Empfohlen: Llama 3 8B auf 16 GB

RAG-Pipeline

Erstellen Sie ein Retrieval-Augmented-Generation-System, das Ihre Dokumente durchsucht und Antworten generiert. Verwenden Sie ChromaDB oder Qdrant für Embeddings mit Ollama für die Generierung.

Empfohlen: Mistral 7B auf 16 GB

Codegenerierung

Verwenden Sie spezialisierte Coding-Modelle wie CodeLlama oder DeepSeek Coder für Autovervollständigung, Code-Review und automatisiertes Refactoring. Integrieren Sie sie über Continue.dev mit VS Code oder JetBrains.

Empfohlen: CodeLlama 34B auf 48 GB

Content-Generierung

Generieren Sie Marketingtexte, Blogbeiträge, Produktbeschreibungen und E-Mail-Vorlagen in großem Umfang. Führen Sie über Nacht Batch-Jobs aus, ohne dass sich API-Kosten pro Token summieren.

Empfohlen: Llama 3 70B auf 48 GB

Performance-Tipps

Wählen Sie die richtige Quantisierung

Der Quantisierungsgrad beeinflusst sowohl Geschwindigkeit als auch Qualität dramatisch. Q4_K_M bietet für die meisten Anwendungsfälle das beste Gleichgewicht.

# Quantization levels (from fastest to best quality):
# Q2_K  - Fastest, lowest quality, smallest size
# Q3_K  - Fast, acceptable quality
# Q4_K_M - Best balance of speed and quality (RECOMMENDED)
# Q5_K_M - Slower, better quality
# Q6_K  - Slow, near-original quality
# Q8_0  - Slowest, best quality, largest size
# F16   - Full precision, requires 2x memory

# Example: Download Q4_K_M for best balance
ollama pull llama3:8b-instruct-q4_K_M

Metal-GPU-Offloading maximieren

Stellen Sie sicher, dass alle Modellschichten auf der GPU laufen, um maximale Leistung zu erzielen. Teilweises CPU-Offloading reduziert den Durchsatz erheblich.

# llama.cpp: offload all layers to GPU
./build/bin/llama-cli -m model.gguf -ngl 99

# Check GPU utilization
sudo powermetrics --samplers gpu_power -n 1 -i 1000

# Monitor memory pressure
memory_pressure
# System-wide memory free percentage: 45%

Batch-Größe und Kontext optimieren

Das Verkleinern des Kontextfensters gibt Speicher frei und kann den Durchsatz verbessern. Verwenden Sie nur so viel Kontext, wie Ihre Anwendung tatsächlich benötigt.

# Default context is often 4096 or 8192 tokens
# Reduce if you don't need long context.
# Ollama: set it inside an interactive session...
ollama run llama3:8b
# >>> /set parameter num_ctx 2048

# ...or as the default for every model the server loads: add it to the
# EnvironmentVariables dict of ~/Library/LaunchAgents/com.ollama.server.plist
# (Step 6), then reload the service (a variable set in a shell does not
# reach the launchd service, and a second ollama serve would clash on port 11434)
#   <key>OLLAMA_CONTEXT_LENGTH</key>
#   <string>2048</string>
launchctl unload ~/Library/LaunchAgents/com.ollama.server.plist
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# For llama.cpp, set context and batch size:
#   -c 2048       Context window
#   -b 512        Batch size for prompt processing
#   --parallel 2  Concurrent request slots
./build/bin/llama-server -m model.gguf -ngl 99 \
  -c 2048 \
  -b 512 \
  --parallel 2

Modelle im Speicher warm halten

Das Laden eines Modells von der Festplatte dauert mehrere Sekunden. Halten Sie häufig verwendete Modelle im Speicher resident, um sofortige Antworten zu erhalten.

# Ollama: set keep-alive to keep model in memory indefinitely
curl http://localhost:11434/api/generate -d '{
  "model": "llama3:8b",
  "keep_alive": -1
}'

# Or make it the server default: add OLLAMA_KEEP_ALIVE to the
# EnvironmentVariables dict of the Step 6 plist, then reload the service
#   <key>OLLAMA_KEEP_ALIVE</key>
#   <string>-1</string>
launchctl unload ~/Library/LaunchAgents/com.ollama.server.plist
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# Check which models are loaded
ollama ps

Häufig gestellte Fragen

Kann ich Modelle auf ChatGPT-Niveau auf einem Mac Mini M4 ausführen?
Ja. Modelle wie Llama 3 8B und Mistral 7B liefern für viele Aufgaben eine mit GPT-3.5 vergleichbare Qualität. Für eine Qualität auf GPT-4-Niveau benötigen Sie ein 70B-Modell, das 48 GB+ Unified Memory erfordert (Mac Mini M4 Pro). Das Erlebnis ist hervorragend für Coding-Unterstützung, Dokument-Q&A und Content-Generierung.
Sind 35 Tokens/Sekunde schnell genug für Echtzeit-Chat?
Absolut. Die durchschnittliche menschliche Lesegeschwindigkeit beträgt etwa 4-5 Wörter pro Sekunde, was ungefähr 5-7 Tokens pro Sekunde entspricht. Bei 35 Tok/s generiert das Modell Text 5-7x schneller, als ein Mensch ihn lesen kann. Für Chat-Anwendungen wirkt das völlig augenblicklich.
Wie viele gleichzeitige Nutzer kann ein Mac Mini M4 bewältigen?
Mit einem 7B-Modell kann ein einzelner Mac Mini M4 2-4 gleichzeitige Anfragen mit akzeptabler Latenz bewältigen. Für höhere Nebenläufigkeit können Sie mehrere Mac Minis hinter einem Load Balancer betreiben. Sowohl die Ollama- als auch die llama.cpp-Server unterstützen das Warteschlangen-Management gleichzeitiger Anfragen.
Kann ich Modelle auf dem Mac Mini M4 feinabstimmen?
Ja, mit Einschränkungen. Sie können 7B-Modelle mit LoRA/QLoRA auf Geräten mit 16 GB mit MLX oder der Hugging-Face-PEFT-Bibliothek feinabstimmen. Das vollständige Feintuning größerer Modelle erfordert mehr Speicher. Für das produktive Feintuning von Modellen mit 70B+ sind GPU-Server praktischer.
Welches Framework soll ich wählen: Ollama, llama.cpp oder MLX?
Wählen Sie Ollama, wenn Sie die schnellste Einrichtung und einfaches API-Serving wünschen. Wählen Sie llama.cpp für maximale Kontrolle über die Inferenzparameter und die beste GGUF-Modellleistung. Wählen Sie MLX, wenn Sie Python-ML-Pipelines erstellen und native Apple-Silicon-Optimierung wünschen. Viele Nutzer beginnen mit Ollama und wechseln mit wachsenden Anforderungen zu llama.cpp oder MLX.

Beginnen Sie mit dem Ausführen von LLMs auf Apple Silicon

Erhalten Sie einen dedizierten Mac-Mini-M4-Server und führen Sie Llama, Mistral oder Phi mit unbegrenzter Inferenz aus. Ab 85 $/Monat (USD, exkl. Steuern).

Mehr Details gesucht?

Durchsuchen Sie die vollständige Dokumentation für Schritt-für-Schritt-Anleitungen, Konfigurationsreferenzen und Fehlerbehebung.

Dokumentation öffnen →