Microsoft Phi-4 lokal betreiben: 14B Reasoning-Modell auf Consumer-GPU

Microsoft Phi-4 ist ein 14-Milliarden-Parameter-Modell, das trotz seiner kompakten Größe auf Reasoning- und Mathe-Benchmarks mit GPT-4o mithalten kann – und ihn in einigen Disziplinen sogar übertrifft. Mit 80,4 % auf dem MATH-Benchmark (GPT-4o: 74,6 %) und 56,1 % auf GPQA (GPT-4o: 50,6 %) ist Phi-4 das stärkste öffentlich verfügbare „Klein-Modell" für analytische Aufgaben. Die MIT-Lizenz erlaubt kommerzielle Nutzung und Fine-Tuning ohne Einschränkungen. Diese Anleitung zeigt, wie du Phi-4 entweder per Ollama (Linux/macOS/Windows) oder per Microsoft Foundry Local (Windows-nativ, kaum bekannt) auf Consumer-Hardware deployst – und welche Quantisierungsstufe für deine GPU die richtige ist.

Voraussetzungen

1. GPU mit mindestens 8 GB VRAM – empfohlen RTX 3080 (10 GB oder 12 GB) für Phi-4 14B; Phi-4-mini läuft ab 3–4 GB VRAM
2. Aktueller NVIDIA-Treiber (für CUDA-Beschleunigung in Ollama und llama.cpp)
3. Ollama installiert (ollama.com) – verfügbar für Windows, Linux und macOS
4. Für Foundry Local: Windows 10 Build 26100 oder höher (Windows 11 24H2 empfohlen), DirectX-12-GPU, winget (in Windows 11 vorinstalliert)
5. Für SDK-Integration: Python 3.11+, .NET 8+ oder Node.js 20+
6. Internetzugang für den initialen Modell-Download (Phi-4 14B Q4_K_M: ca. 9,1 GB)
7. Optional: Hugging Face Account (kostenlos) für direkten GGUF-Download von bartowski/phi-4-GGUF

Phi-4 im Überblick: Warum das Modell besonders ist

Die meisten kleinen Sprachmodelle erkaufen sich ihre kompakte Größe mit Qualitätsverlusten. Phi-4 geht einen anderen Weg: Microsoft hat das Modell auf 9,8 Billionen Token trainiert, davon ein ungewöhnlich hoher Anteil synthetischer Lehrbuchdaten. Das Prinzip „Qualität vor Quantität" zahlt sich auf Reasoning-Aufgaben aus – also genau dort, wo lokale Modelle bisher am stärksten zurücklagen.

Phi-4-mini (3,8B) ist die kompaktere Variante, die bereits auf 4-GB-Karten läuft. Für spezialisierte Reasoning-Szenarien gibt es zudem phi-4-mini-reasoning als Foundry-Local-Alias. Der folgende Benchmark-Vergleich zeigt, wo Phi-4 im Konkurrenzfeld steht:

Ein wichtiger Vorbehalt: Phi-4 ist überwiegend auf englische Daten trainiert (mehrsprachige Inhalte machen nur rund 8 % des Trainingkorpus aus). Für deutsche Texte kann die Qualität variieren; englische Prompts liefern konsistentere Ergebnisse.

Schritt 1: Quantisierung und VRAM wählen

Bevor du den Download startest, solltest du wissen, welche Quantisierungsstufe für deine GPU passt. Die folgende Tabelle gibt eine Übersicht – alle Werte beziehen sich auf Phi-4 14B via Ollama oder llama.cpp:

Faustregel RTX 3080 10 GB: Verwende Q4_K_S für stabilen Betrieb. Q4_K_M ist möglich, aber knapp – bei hoher Kontextlänge kann es zu OOM-Fehlern kommen. Die RTX 3080 12 GB hat ausreichend Puffer für Q4_K_M. Auf 8-GB-Karten (RTX 3070) bleibt nur Q3_K_M für vollständige GPU-Inferenz.

Schritt 2: Phi-4 per Ollama deployen

Ollama ist der einfachste Einstieg und läuft plattformübergreifend. Nach der Installation reicht ein einziger Befehl, um Phi-4 herunterzuladen und zu starten:

# Phi-4 14B (Standard Q4_K_M, 9,1 GB) – herunterladen und sofort starten:
ollama run phi4:14b

# Phi-4-mini (3,8B, ca. 2,2 GB) – für 4–8 GB VRAM:
ollama run phi4:mini

# Explizit eine schmalere Quantisierung wählen (RTX 3080 10 GB):
ollama pull phi4:14b-q5_K_M

Ollama lädt das Modell automatisch herunter (beim ersten Aufruf) und öffnet dann eine interaktive Chat-Shell. Auf 10-GB-Karten empfiehlt es sich, statt des Standard-Tags explizit phi4:14b-q5_K_M zu ziehen – dieser Tag ist kompakter und gibt der GPU mehr Puffer für den KV-Cache.

Verifizieren: Nach dem Download zeigt ollama list das Modell mit korrekter Größe und Quantisierungsinformation. nvidia-smi sollte während der Inferenz einen VRAM-Verbrauch nahe der erwarteten Größe anzeigen.

# Installierte Modelle anzeigen:
ollama list

# VRAM-Auslastung während Inferenz prüfen:
nvidia-smi

Für Anwendungen, die eine API benötigen, stellt Ollama automatisch einen OpenAI-kompatiblen Endpunkt unter http://localhost:11434 bereit. Damit lässt sich Phi-4 direkt in Tools wie Open WebUI oder in eigene Skripte einbinden.

Schritt 3: Phi-4 per Microsoft Foundry Local deployen (Windows)

Microsoft Foundry Local ist der Windows-native Deploymentweg für Phi-4 – und kaum bekannt außerhalb der Microsoft-Entwicklercommunity. Das Tool ist ca. 20 MB groß, benötigt keine Azure-Subscription und läuft vollständig lokal ohne Internetverbindung nach dem initialen Modell-Download. Die automatische Hardware-Erkennung wählt zwischen NVIDIA CUDA, Qualcomm NPU und CPU-Fallback – ohne manuellen Eingriff.

Installation:

# 1. Foundry Local über winget installieren:
winget install Microsoft.FoundryLocal

# 2. Neues Terminal öffnen (wichtig! PATH wird erst dann aktualisiert)

# 3. Installation prüfen:
foundry --version

Modelle entdecken und starten:

# Verfügbare Modelle anzeigen (Aliase exakt notieren!):
foundry model list

# Phi-4-mini starten (empfohlen ab 8 GB VRAM, schneller Start):
foundry model run phi-4-mini

# Phi-4 (14B) starten (ab 10–12 GB VRAM):
foundry model run phi-4

# Phi-4-mini-reasoning (spezialisiert auf Reasoning-Aufgaben):
foundry model run phi-4-mini-reasoning

Verifizieren: Nach foundry model run phi-4-mini öffnet sich eine interaktive Shell. Eine Testfrage sollte innerhalb weniger Sekunden eine kohärente Antwort liefern. Foundry Local gibt beim Start die erkannte Hardware und das verwendete Backend (ONNX Runtime / Windows ML) aus.

Schritt 4: Foundry Local per Python-SDK einbinden

Für eigene Anwendungen bietet Foundry Local SDKs für Python, C#, JavaScript und Rust. Auf Windows mit NVIDIA-GPU empfiehlt sich das WinML-Paket für Hardware-Beschleunigung. Ein häufiger Stolperstein vorab: Das offizielle Paket heißt foundry-local-sdk-winml – nicht foundry-local, das ein fremdes Drittanbieter-Paket ist.

# Offizielles SDK installieren (Windows + GPU):
pip install foundry-local-sdk-winml openai
# app.py – Phi-4-mini mit Foundry Local SDK (Windows)
from foundry_local_sdk import Configuration, FoundryLocalManager

FoundryLocalManager.initialize(Configuration(app_name="mein-phi4-test"))
manager = FoundryLocalManager.instance

# Modell aus Katalog holen und laden
model = manager.catalog.get_model("phi-4-mini")
model.download(lambda p: print(f"\r{p:.0f}%", end="", flush=True))
model.load()

# OpenAI-kompatibler Chat-Client
client = model.get_chat_client()
for chunk in client.complete_streaming_chat(
    [{"role": "user", "content": "Erkläre Newtons drittes Gesetz auf Englisch."}]
):
    print(chunk.choices[0].delta.content or "", end="", flush=True)

model.unload()

Für C# (.NET 8+) und Node.js 20+ gibt es analoge WinML-Pakete:

# C# / .NET:
dotnet add package Microsoft.AI.Foundry.Local.WinML
dotnet add package OpenAI

# Node.js:
npm install foundry-local-sdk-winml openai

Foundry Local exponiert zusätzlich eine OpenAI-kompatible REST-API auf einem lokalen Port. Das ermöglicht die Einbindung in beliebige Tools, die OpenAI-kompatible Endpunkte unterstützen – ohne Code-Änderungen.

Schritt 5: Phi-4 direkt per llama.cpp (GGUF)

Wer maximale Kontrolle über Quantisierung, Kontextlänge und Sampling-Parameter benötigt, kann Phi-4 auch direkt über llama.cpp laufen lassen. Die GGUF-Dateien stellt der Community-Maintainer bartowski auf Hugging Face bereit:

# GGUF-Datei direkt von Hugging Face laden:
pip install huggingface_hub
huggingface-cli download bartowski/phi-4-GGUF phi-4-Q4_K_M.gguf --local-dir ./models

# Inferenz starten (-ngl 999 = alle Layer auf GPU, -c 16384 = volles Kontextfenster):
./llama-cli -m models/phi-4-Q4_K_M.gguf -ngl 999 -c 16384 -fa --temp 0.4 --min-p 0.05

Der Parameter -c 16384 ist wichtig: llama.cpp verwendet standardmäßig nur 2.048 Token Kontext. Phi-4 unterstützt 16.384 Token – ohne explizite Angabe wird dieses Potenzial verschenkt. -fa aktiviert Flash Attention für niedrigeren VRAM-Verbrauch bei langen Kontexten.

Troubleshooting / Typische Fehler

Falsches PyPI-Paket installiert

pip install foundry-local installiert ein fremdes Drittanbieter-Paket, nicht das offizielle SDK. Das offizielle Paket heißt foundry-local-sdk (plattformübergreifend) oder foundry-local-sdk-winml (Windows mit Hardware-Beschleunigung). Im Zweifel: pip show foundry-local-sdk-winml zeigt an, ob das richtige Paket installiert ist.

Paket-Konflikt: foundry-local-sdk und foundry-local-sdk-winml

Beide Pakete pinnen unterschiedliche Versionen von onnxruntime-core und können nicht gleichzeitig in derselben Python-Umgebung installiert sein. Lösung: Eine virtuelle Umgebung (python -m venv .venv) pro Projekt verwenden und nur eines der beiden Pakete installieren.

OOM auf RTX 3080 10 GB mit Q4_K_M

Q4_K_M belegt rund 10–12 GB VRAM. Bei der 10-GB-Variante der RTX 3080 kann es bei langen Prompts zu Out-of-Memory-Fehlern kommen. Lösung: ollama pull phi4:14b-q4_K_S verwenden (ca. 10 GB, stabiler) oder die Kontextlänge begrenzen.

foundry-Befehl nach Installation nicht gefunden

Nach winget install Microsoft.FoundryLocal muss das Terminal neu geöffnet werden, damit der foundry-Befehl im PATH verfügbar ist. In der gleichen Terminal-Session funktioniert der Befehl noch nicht.

Falscher Modell-Alias in Foundry Local

Die Aliase phi-4 und phi-4-mini müssen exakt stimmen. Ein Tippfehler führt zu einer unklaren Fehlermeldung. Zuerst immer foundry model list ausführen und den genauen Alias kopieren.

Foundry Local in VMs ohne GPU-Passthrough

Das WinML-Backend benötigt eine physische DirectX-12-GPU. In VMs ohne GPU-Passthrough liefert das Modell leere Antworten – ohne Fehlermeldung. In diesem Szenario ist Ollama die bessere Wahl (CPU-Fallback funktioniert dort zuverlässig).

OGA-Warnings beim Programmende

Meldungen wie „N instances leaked" nach dem Programmende stammen vom ONNX Runtime GenAI und sind harmlos. Sie weisen auf interne Cleanup-Verzögerungen hin, nicht auf Fehler im eigenen Code.

Schlechtere Qualität bei deutschen Prompts

Phi-4 wurde überwiegend auf englischen Daten trainiert (ca. 8 % mehrsprachig). Für anspruchsvolle Reasoning-Aufgaben liefern englische Prompts konsistentere Ergebnisse. Deutsche Alltagstexte funktionieren gut, aber komplexe mehrstufige Schlussfolgerungen auf Deutsch können qualitativ abfallen.

Häufige Fragen

Läuft Phi-4 14B auf einer RTX 3080 mit 10 GB VRAM?

Mit Q4_K_S (ca. 10 GB VRAM-Bedarf) ist das möglich, aber knapp. Empfehlenswert ist die RTX 3080 12-GB-Variante für Q4_K_M. Auf der 10-GB-Karte solltest du kurze Kontextlängen verwenden und Q4_K_S wählen. Alternativ: Phi-4-mini (3,8B) läuft komfortabel auf 4–8 GB.

Was ist der Unterschied zwischen Phi-4 und Phi-4-mini?

Phi-4 hat 14B Parameter und erreicht GPT-4o-Niveau auf Reasoning-Tasks (MATH: 80,4 %). Phi-4-mini hat 3,8B Parameter, ist deutlich schneller und passt auf kleinere GPUs, erreicht aber nur 62 % auf MATH. Für einfache Code-Assistenz oder schnelle Antworten ist Phi-4-mini eine gute Wahl; für komplexe Analysen empfiehlt sich das vollständige Phi-4.

Muss ich für Microsoft Foundry Local Azure bezahlen?

Nein. Foundry Local läuft vollständig lokal ohne Azure-Subscription oder Internetverbindung nach dem initialen Download. Es ist kostenlos nutzbar und speichert keine Daten in der Cloud.

Kann ich Foundry Local und Ollama gleichzeitig nutzen?

Ja, beide laufen unabhängig voneinander. Ollama belegt standardmäßig Port 11434, Foundry Local nutzt einen anderen Port. Beide bieten OpenAI-kompatible APIs, sodass Anwendungen bei Bedarf zwischen beiden wechseln können.

Ist Phi-4 für kommerzielle Projekte geeignet?

Ja. Die MIT-Lizenz erlaubt uneingeschränkte kommerzielle Nutzung, Fine-Tuning und Weitergabe – auch in proprietären Produkten. Es gibt keine Nutzungsbeschränkungen oder Lizenzgebühren.

Welche Programmiersprachen unterstützt das Foundry Local SDK?

Python, C# (.NET 8+), JavaScript (Node.js 20+) und Rust. Für Windows mit Hardware-Beschleunigung gibt es jeweils WinML-Varianten der Pakete (-winml-Suffix). Die plattformübergreifenden Varianten laufen auch auf Linux und macOS, nutzen dann aber keinen Windows-ML-Beschleuniger.

Fazit

Phi-4 ist das derzeit überzeugendste „Klein-Reasoning-Modell" für den lokalen Betrieb. Wer eine RTX 3080 (12 GB) oder eine RTX 4070 hat, bekommt mit ollama run phi4:14b in wenigen Minuten ein Modell, das GPT-4o auf Mathe und Wissenschaft schlägt – ohne Cloud-Kosten, ohne Datenschutzbedenken, vollständig offline. Microsoft Foundry Local ist dabei der interessante Newcomer: Der Windows-native Weg mit automatischer Hardware-Erkennung und OpenAI-kompatibler API ist besonders für Entwickler attraktiv, die Phi-4 in eigene Anwendungen einbetten möchten, ohne eine Server-Infrastruktur aufzubauen. Für 8-GB-Karten ist Phi-4-mini (3,8B) der pragmatische Einstieg.

Wer Phi-4 in eine vollständige lokale KI-Umgebung einbetten möchte, findet in der Ollama + Open WebUI Anleitung den passenden nächsten Schritt. Für die Modellwahl abseits von Phi-4 – inklusive detaillierter VRAM- und Quantisierungsempfehlungen – lohnt sich ein Blick in die Übersicht Ollama-Modelle 2026 richtig auswählen. Wer das nächste Reasoning-Modell im Cluster kennenlernen möchte, findet in DeepSeek R1 lokal betreiben eine direkte Ergänzung.

Weiterführende Anleitungen und Quellen

1. Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud betreiben
2. Ollama-Modelle 2026 richtig auswählen: VRAM, Quantisierung und Modellvergleich für KMU
3. DeepSeek R1 lokal betreiben: Modellwahl, Quantisierung und VRAM-Bedarf
4. GGUF, AWQ und GPTQ erklärt: Welches Quantisierungsformat für welchen Zweck
5. Microsoft Phi-4 – Hugging Face Modellkarte (offiziell)
6. Ollama Library – phi4:14b
7. Microsoft Learn – Get started with Foundry Local (Windows AI)

Passende Anleitungen auf S-EDV

1. GPT-5.5-Cyber: OpenAI startet Sicherheitsmodell als Konkurrenz zu Anthropic Myth
2. Anthropic veröffentlicht Claude Fable 5 und Mythos 5: Frontier-Modell mit Sicher
3. NVIDIA GPU Display Driver: 14 Sicherheitslücken geschlossen – Update dringend nö