Claude Code mit lokalen LLMs und ANTHROPIC_BASE_URL: Ollama, LM Studio, llama.cpp, vLLM

Native Anthropic-Endpoints, Tool-Call-Kompatibilität und Context-Window-Sizing für lokales Claude Code.

Zuletzt getestet: April 2026. Siehe Changelog am Ende.

TL;DR Cheat Sheet

Die Faustregel für lokales Claude Code

Drei Faktoren entscheiden, ob eine lokale Claude-Code-Session funktioniert:

• Modellqualität entscheidet, ob die Antwort schlau ist.
• Tool-Call-Formatierung entscheidet, ob Claude Code mit der Antwort handeln kann.
• Context-Länge entscheidet, ob die Session die ersten paar Edits überlebt.

Für lokale Coding-Agents: 32K ist die Untergrenze. 64K ist der Sweet Spot. Alles unter 32K ist eine Chat-Demo, kein Claude Code.

Empfohlenes Setup

Nimm das hier zuerst. Schau dir die Alternativen erst an, wenn du das ausprobiert hast.

• Backend: LM Studio (≥ 0.4.1) oder Ollama (≥ v0.14.0) — beide bieten einen nativen Anthropic-kompatiblen lokalen Endpoint, kein Proxy nötig.
• Modell: gemma4:26b-a4b (Gemma 4 26B-A4B-it, Q4-Quant). MoE Active-Param ≈ 3,88 B → laptopfreundliche Latenz, Tool-Use ist direkt ins Modell trainiert.
• Context: 32K Context auf einem MacBook Air, 64K Context auf einem MacBook Pro M5 Pro/Max mit 48 GB+ RAM.
• Maschine: 32 GB+ RAM dringend empfohlen. 24 GB funktioniert bei 24K–32K mit Vorsicht.

Wenn du keinen Anthropic-kompatiblen Modus hast und nur einen OpenAI-kompatiblen lokalen Endpoint läufst, setz LiteLLM davor (siehe Abschnitt zu LiteLLM).

1. Environment Variables, die Claude Code liest

# Wohin Claude Code Requests POSTet. Default: https://api.anthropic.com
ANTHROPIC_BASE_URL=http://localhost:11434

# Wird als Auth gesendet. Lokale Server akzeptieren meist jeden nicht-leeren Wert.
ANTHROPIC_AUTH_TOKEN=ollama

# Mappe Claude Codes "claude-opus-X-Y" / "claude-sonnet-X-Y" / "claude-haiku-X-Y"
# auf Modellnamen, die dein lokales Backend serviert.
ANTHROPIC_DEFAULT_OPUS_MODEL=gemma4:26b-a4b
ANTHROPIC_DEFAULT_SONNET_MODEL=gemma4:26b-a4b
ANTHROPIC_DEFAULT_HAIKU_MODEL=gpt-oss:20b

claude

Oder pro Aufruf überschreiben:

claude --model gemma4:26b-a4b

Wenn ANTHROPIC_BASE_URL gesetzt ist, die URL aber nicht mit der richtigen Shape antwortet, fällt Claude Code nicht auf die Cloud zurück. Es wirft einen Fehler.

2. Context-Länge: der versteckte Failure-Mode

Claude Code ist kein Chat-Prompt. Vor deinem eigentlichen Request sieht das Backend:

• Claude Codes System-Prompt (~6–10K Token allein)
• Tool-Definitionen für Read / Edit / Bash / Grep / Glob / TodoWrite
• Konversationshistorie
• Datei-Auszüge und vollständige Reads
• Diffs
• Befehlsausgabe
• Retry-/Error-Messages aus fehlgeschlagenen Tool-Calls

Das heißt: 8K- und 16K-Kontexte sind irreführende Tests. Sie können eine Chat-Frage beantworten, sind aber nicht genug für zuverlässiges agentisches Coding. Die Session überlebt eine Handvoll Turns, dann degradiert sie still — Datei-Edits werden abgeschnitten, Tool-Calls verlieren Argumente, der Loop verheddert sich.

Praktische Context-Stufen

Apple-Silicon Context-Presets

Hinweis: Backend-Docs sind sich nicht einig — LM Studio sagt “ab 25K, höher für bessere Ergebnisse”, Ollama empfiehlt 32K. Nimm 32K als Cross-Backend-Baseline. “25K ist genug” zu lesen, ist der häufigste Fehler.

3. Claude-Code-Setup mit Ollama (nativ, v0.14.0+)

Ollama hat am 2026-01-16 die Anthropic-Messages-API-Kompatibilität angekündigt. Kein Proxy, kein LiteLLM, nichts.

# Context-Länge zuerst setzen — das ist der wichtigste Knopf
export OLLAMA_CONTEXT_LENGTH=32768   # 65536 auf einem Pro

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_BASE_URL=http://localhost:11434

claude --model gemma4:26b-a4b

Cloud-gehostete Ollama-Modelle funktionieren auch:

claude --model glm-4.7:cloud
claude --model minimax-m2.1:cloud

Zwei bekannte Limits des Anthropic-Compat-Layers von Ollama (April 2026):

• Kein Prompt-Caching. Anthropics cache_control greift nicht — jeder Claude-Code-Request verarbeitet System-Prompt und Konversationshistorie von Grund auf neu.
• Kein tool_choice. Claude Code nutzt gelegentlich tool_choice, um einen bestimmten Tool-Call zu erzwingen. Ollamas Compat-Layer ignoriert das. Wenn es darauf ankommt, wählt Claude Code möglicherweise das falsche Tool und steckt im Loop fest.

4. Claude-Code-Setup mit LM Studio (nativ, 0.4.1+)

LM Studio hat den Anthropic-kompatiblen /v1/messages-Endpoint am 2026-01-30 hinzugefügt. Streaming, Tool-Calls und Message-Shape werden alle nativ unterstützt.

# Context auf mindestens 32K im LM Studio UI setzen (oder höher; siehe Abschnitt 2)
lms server start --port 1234

export ANTHROPIC_BASE_URL=http://localhost:1234
export ANTHROPIC_AUTH_TOKEN=lmstudio

claude --model openai/gpt-oss-20b

Für VS Code mit der Claude-Code-Extension (Env-Vars aus deiner Shell werden NICHT von VS Code geerbt):

// .vscode/settings.json
"claudeCode.environmentVariables": [
  { "name": "ANTHROPIC_BASE_URL", "value": "http://localhost:1234" },
  { "name": "ANTHROPIC_AUTH_TOKEN", "value": "lmstudio" }
]

Die Docs von LM Studio sagen “mindestens 25K”. Setz 32K. Siehe Abschnitt 2.

5. Claude-Code-Setup mit llama.cpp (Apple-Silicon-Fast-Path für Gemma 4 26B-A4B)

Wenn du auf Apple Silicon bist und absolut minimalen Overhead mit Gemma 4 26B-A4B willst, ist der Server von llama.cpp pro Token schneller als Ollama oder LM Studio. Du brauchst einen aktuellen Build (einer, der -hf für HuggingFace-Pulls und --jinja für Chat-Templates unterstützt).

./build/bin/llama-server \
  -hf ggml-org/gemma-4-26B-A4B-it-GGUF:Q4_K_M \
  --host 127.0.0.1 \
  --port 8080 \
  -ngl 99 \
  -c 65536 \
  --jinja

export ANTHROPIC_BASE_URL=http://localhost:8080
export ANTHROPIC_AUTH_TOKEN=llama-cpp
claude --model gemma-4-26B-A4B

Flags, die zählen:

• -c 65536 setzt 64K Context (auf engeren Maschinen -c 32768).
• -ngl 99 lagert alle Layer auf Metal/GPU aus.
• --jinja ist erforderlich, damit das Chat-Template von Gemma 4 korrekt rendert. Ohne das formatieren Tool-Calls nicht und du siehst <unused24> / <unused49>-Token im Output.
• -hf ggml-org/gemma-4-26B-A4B-it-GGUF:Q4_K_M zieht das GGUF direkt von HuggingFace.

Caveat: Die Anthropic-Compat von llama.cpp ist partiell. Funktioniert für Chat und einfaches Tool-Calling. Streaming-Shape und einige Anthropic-spezifische Request-Felder sind rauer als bei Ollama oder LM Studio. Wenn etwas seltsam bricht, fall auf Ollama zurück. llama.cpp ist der Speed-Play, nicht der Compatibility-Play.

6. Claude-Code-Setup mit vLLM (nativ + Tool-Parser)

vLLM liefert eine offizielle Claude-Code-Integration. Drei Dinge beim Server-Start: ein Tool-Calling-fähiges Modell, --enable-auto-tool-choice und der richtige --tool-call-parser.

vllm serve openai/gpt-oss-120b \
  --served-model-name my-model \
  --enable-auto-tool-choice \
  --tool-call-parser openai \
  --port 8000

export ANTHROPIC_BASE_URL=http://localhost:8000
export ANTHROPIC_API_KEY=dummy
export ANTHROPIC_AUTH_TOKEN=dummy
export ANTHROPIC_DEFAULT_OPUS_MODEL=my-model
export ANTHROPIC_DEFAULT_SONNET_MODEL=my-model
export ANTHROPIC_DEFAULT_HAIKU_MODEL=my-model

claude

Der Wert von --tool-call-parser hängt von der Modellfamilie ab — openai für die gpt-oss-Familie, llama3_json für Llama 3.x, hermes für Hermes. Falscher Parser → Tool-Calls kommen als Plain-Text zurück und Claude Codes edit/grep/bash-Tools machen still einen No-Op.

7. LiteLLM — für Fallbacks, nicht für Übersetzung

Da Ollama, LM Studio, llama.cpp und vLLM jetzt alle nativ Anthropic sprechen, ändert sich die Rolle von LiteLLM. Es ist nicht mehr “der Übersetzer” — es ist der Router für Fallbacks, Request-Logging, Per-Tenant-Keys und Rate-Limits. Auch die richtige Antwort, wenn deine einzige lokale Option ein OpenAI-kompatibler lokaler Endpoint ist.

# litellm-config.yaml
model_list:
  - model_name: claude-opus-4-7
    litellm_params:
      model: openai/my-vllm-model
      api_base: http://vllm:8000/v1

  - model_name: claude-sonnet-4-6
    litellm_params:
      model: ollama/gemma4:26b-a4b
      api_base: http://ollama:11434

  - model_name: claude-haiku-4-5
    litellm_params:
      model: anthropic/claude-haiku-4-5
      api_key: os.environ/ANTHROPIC_API_KEY

router_settings:
  fallbacks:
    - claude-opus-4-7: ["claude-haiku-4-5"]   # local fail → cloud Haiku

Der größte Einzelnutzen: wenn ein lokaler Tool-Call still scheitert, fällt LiteLLM transparent auf Cloud-Haiku zurück. Claude Code läuft weiter.

8. Häufige Fehler (die Error-Strings, nach denen Entwickler googeln)

tool_use parse error / invalid tool call / tool_use is not supported

Drei verschiedene Symptome, eine Ursache: das Modell emittiert keine tool_use-Content-Blöcke im Anthropic-Format.

Das tückischste Symptom ist das stille — Claude Code startet, druckt die Plain-Prosa-Antwort des Modells (“Ich würde die Datei so ändern…”) und nichts passiert. Kein File-Edit, kein Fehler.

Häufige Ursachen (April 2026):

• vLLM: --enable-auto-tool-choice fehlt oder --tool-call-parser ist falsch.
• Ollama: Modell wurde nicht für Tool-Calling trainiert (Stock llama3.x Instruct vermeiden).
• llama.cpp: --jinja fehlt. Das Chat-Template rendert falsch und du siehst literale <unused24> / <unused49>-Token.
• LM Studio: Modell-Datei ist okay, aber das geladene Preset nutzt das falsche Template.

context length exceeded / Modell stoppt mitten im Edit

Die Prompts von Claude Code überlaufen das konfigurierte Window. Die Session beendet vielleicht einen Turn, dann wird der nächste File-Edit still abgeschnitten. Fix: Context auf mindestens 32K erhöhen. Wenn du schon bei 32K bist und das immer noch trifft, liest das Modell zu aggressiv — weniger Tools oder kürzere File-Reads.

empty assistant response

Backend hat 200 OK mit leerem Content-Array zurückgegeben. Ursachen:

• Streaming-SSE-Format-Mismatch (meist llama.cpp).
• Tool-Call-Parser hat die Message verschluckt, weil er sie nicht parsen konnte.
• Modell hat nur einen <unused24> / <unused49>-Token emittiert und der Parser hat den Rest verworfen.

Fix: Backend wechseln (Ollama oder LM Studio, falls du auf llama.cpp warst), oder llama.cpp auf einen Build mit gepatchtem Gemma-4-Chat-Template upgraden.

model not found / 404 the model X does not exist

Claude Code hat nach claude-opus-4-7 gefragt, aber das Backend serviert gpt-oss:20b oder gemma4:26b-a4b. Fixes:

• ANTHROPIC_DEFAULT_OPUS_MODEL (plus _SONNET_ und _HAIKU_) auf den tatsächlichen Modellnamen des Backends setzen.
• claude --model <backend-name> pro Aufruf nutzen.
• Namen in LiteLLM mappen (das Feld model_name: ist das, wonach Claude Code fragt; model: ist das, was serviert wird).

messages: Extra inputs are not permitted (HTTP 422)

Manche Backends sind strenger als Anthropics eigenes. Sie lehnen Anthropic-spezifische Felder ab (cache_control, thinking, tools[].input_schema, metadata.user_id). Fix: Backend upgraden, oder eine kleine Middleware-Proxy laufen lassen, die unsupported Felder vor dem Forwarden strippt.

ANTHROPIC_BASE_URL ignoriert / Claude Code ruft immer noch die echte API

• Env-Var wurde in .zshrc nach dem Shell-Start gesetzt — Terminal neu starten.
• ~/.config/claude/config.json oder ein --api-key-Flag überschreibt die Env-Var.
• VS Code: Env-Vars aus deiner Shell werden NICHT geerbt. Nutze claudeCode.environmentVariables in Workspace-Settings (Abschnitt 4).

echo $ANTHROPIC_BASE_URL in derselben Shell, die claude startet. Wenn leer, hast du ein Sourcing-Problem.

9. Debug-Flow

Wenn etwas bricht, geh diesen Baum durch, bevor du Backends wechselst:

1. Hat das Modell geladen?
   • Nein → Quant-Größe vs RAM prüfen. 26B-A4B Q4 braucht ~16 GB frei; größere Quants brauchen mehr.
2. Ist der Context mindestens 32K?
   • Nein → auf 32K (Air) oder 64K (Pro) erhöhen. Siehe Abschnitt 2.
3. Sind Tool-Calls fehlerhaft? (Schau nach <unused24>, <unused49>, Plain-Prosa wo du einen Edit erwartet hast.)
   • Ja → in den nativen Anthropic-Modus wechseln (Ollama/LM Studio), oder bei vLLM --tool-call-parser verifizieren, oder bei llama.cpp --jinja ergänzen.
4. Stoppt Claude Code mitten im Edit?
   • Ja → Context-Erschöpfung. Context-Targets in deinen Tools senken, oder schnellere Quant nutzen, damit das Modell Turns beendet, bevor der Window-Reuse-Cycle einsetzt.
5. Halluziniert das Modell Dateien, die nicht existieren?
   • Ja → das Modell ruft Read nicht vor Edit. Eine CLAUDE.md-Regel ergänzen, die Read-vor-Edit verlangt, oder ein tool-genaueres Modell nutzen (Gemma 4 26B-A4B ist hier solide).

10. Smoke-Test

Verifiziere dein Setup mit einem Prompt. Frag Claude Code:

Erstelle eine kleine FastAPI-App mit einem /health-Endpoint, füge einen pytest-Test hinzu, lass pytest laufen und behebe Failures.

Besteht, wenn:

• Es Dateien korrekt liest/schreibt (keine halluzinierten Pfade).
• Es den Test-Befehl ausführt (du echte pytest-Ausgabe siehst).
• Es einen Failure patcht (z.B. fehlende Dependency), ohne den Context zu verlieren.
• Es das Tool-Call-Format nicht verliert (kein <unused24> / <unused49>-Leak).
• Es nicht nach dem ersten Edit abschneidet.

Erwartetes Terminal-Feel:

✓ model loaded     (gemma4:26b-a4b, Q4_K_M)
✓ context: 32768
✓ tool call parsed (Edit)
✓ edited file      (app.py)
✓ tool call parsed (Bash)
✓ tests passed

Wenn du nicht alle fünf siehst, geh den Debug-Flow oben durch.

11. Kompatibilitätsmatrix (April 2026)

12. Hardware × Modell × Context × Backend (die Cheat-Sheet-Tabelle)

Ein Entwickler sollte nicht raten müssen, was zu nutzen ist:

Das ist die meistkopierte Tabelle dieses Guides. Bookmarken.

13. Gemma 4 26B-A4B: der Apple-Silicon-Sweet-Spot

Für lokales Mac-Claude-Code ist die herausragende Gemma-4-Variante 26B-A4B-it, nicht die dichte 31B. Gründe:

• Google hat Tool-Use direkt in Gemma 4 reintrainiert (nicht als Fine-Tune drangeschraubt). Es funktioniert beim ersten Versuch, nicht erst nach drei Retries.
• Die 26B MoE aktiviert nur ~3,88 B Parameter pro Inference, also liegt die Latenz im Bereich eines 4-B-Modells — rund 300 Token/Sek auf M2 Ultra.
• Starkes Tool-Use-Verhalten, gute Coding-Qualität für private/lokale Workflows.
• Passt bei brauchbaren Context-Größen auf High-Memory-MacBooks.

Warum 26B-A4B statt 31B?

• Schnellere Tool-Calls — jeder Claude-Code-Turn hängt an Tool-Call-Latenz, nicht an Single-Shot-Qualität.
• Niedrigerer Active-Parameter-Count hält Prefill billig.
• Besser für Laptops — 31B dichtgepackt braucht mehr RAM und mehr Thermal-Headroom.
• Genug Qualität für iteratives Coding; der Agent-Loop zählt mehr als Peak-IQ.
• 31B kann für Single-Shot-Antworten besser sein — aber Claude Code ist viele kleine Turns, nicht eine große Antwort.

Für lokales Coding mit Gemma 4 speziell: nimm 26B-A4B, außer du bist auf einem 64-GB+-Pro und hast gemessen, dass 31B Q4 auf deiner Hardware tatsächlich Turns schneller beendet.

14. Andere Modell-Picks für Claude Code (April 2026)

Wenn Gemma 4 nicht verfügbar ist oder du vergleichen willst:

• gpt-oss:20b — einfacher Einstieg. Tool-Calling zuverlässig, läuft auf einer einzelnen anständigen GPU. In den offiziellen Claude-Code-Blogposts von Ollama und LM Studio empfohlen.
• gpt-oss:120b — deutlich klüger auf echten Codebases. Die vLLM-Claude-Code-Integration nutzt das als Beispiel. Braucht ernsthaft VRAM.
• qwen3-coder — gezielt für Coding gebaut. Starke Tool-Call-Performance auf Ollama. In Community-Threads im März/April 2026 häufig als stärkster lokaler Pick für Claude Code genannt.
• qwen3.5-Familie — die 35B-MoE-Varianten gelten als die stärksten agentischen Coding-Open-Modelle in dieser Größenklasse. Tool-Call-Support pro Quant verifizieren.
• glm-4.7-flash / glm-4.7:cloud — starker agentischer Coder. Verfügbar als Ollama-Cloud-Modell (keine lokale GPU nötig).
• minimax-m2.1:cloud — neuere Ollama-Cloud-Option, agentic-tuned.

Was zu vermeiden ist: Stock-llama3.x-Instruct-Modelle ohne Tool-Fine-Tuning. Sie sehen aus, als würden sie funktionieren, scheitern dann still bei File-Edits.

15. Setups, die ich vermeiden würde

• 8K Context. Zu klein für Claude Code. Der System-Prompt frisst es, bevor dein Code ankommt.
• 16K Context. Nur Demos. Beurteile ein Modell nicht nach 16K-Verhalten.
• Alte llama.cpp-Builds mit Gemma 4. Kein --jinja oder kein gepatchtes Chat-Template → <unused24> / <unused49>-Token-Leak.
• 128K Context auf einem 32-GB-Laptop. KV-Cache + Prefill-Latenz-Steuer > Nutzen.
• Modellqualität beurteilen, bevor Tool-Calls stabil sind. Erst Parser/Template fixen, dann Modell evaluieren.
• Über LiteLLM routen, wenn das Backend bereits nativ Anthropic ist. Hop für nichts — LiteLLM nur für Fallbacks oder zum Wrappen eines OpenAI-kompatiblen lokalen Endpoints nutzen.

16. Wiederverwendbares Startup-Skript

Drop in start-claude-code-local.sh und chmod +x. Default 32K Context, via Env überschreibbar.

#!/usr/bin/env bash
set -euo pipefail

export OLLAMA_CONTEXT_LENGTH="${OLLAMA_CONTEXT_LENGTH:-32768}"
export ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL:-http://localhost:11434}"
export ANTHROPIC_AUTH_TOKEN="${ANTHROPIC_AUTH_TOKEN:-ollama}"
export ANTHROPIC_DEFAULT_OPUS_MODEL="${ANTHROPIC_DEFAULT_OPUS_MODEL:-gemma4:26b-a4b}"
export ANTHROPIC_DEFAULT_SONNET_MODEL="${ANTHROPIC_DEFAULT_SONNET_MODEL:-gemma4:26b-a4b}"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="${ANTHROPIC_DEFAULT_HAIKU_MODEL:-gpt-oss:20b}"

echo "Starte Ollama mit context=$OLLAMA_CONTEXT_LENGTH"
ollama serve &
OLLAMA_PID=$!

# Auf Ollama warten
until curl -sf "$ANTHROPIC_BASE_URL/api/version" > /dev/null; do
  sleep 0.5
done

echo "Starte Claude Code → $ANTHROPIC_BASE_URL"
echo "Modell: $ANTHROPIC_DEFAULT_OPUS_MODEL"

claude

kill $OLLAMA_PID 2>/dev/null || true

Für LM Studio ollama serve durch lms server start --port 1234 ersetzen und Env-Vars entsprechend anpassen.

Dieses Skript (und Ergänzungen für andere Backends, sobald sie kommen) lebt im Companion-Repo:

github.com/renezander030/local-ai-coding-stack — git clone, chmod +x scripts/start-claude-code-local.sh, run.

17. Produktionsempfehlung

Für echte Arbeit lass Claude Code nicht direkt mit einem einzelnen lokalen Endpoint reden, ohne Fallback-Pfad:

Claude Code
   │  ANTHROPIC_BASE_URL
   ▼
LiteLLM (Router + Logger)
   │  primary
   ▼
Ollama / LM Studio / llama.cpp / vLLM (lokal)
   │  bei Tool-Call-Failure oder 5xx
   ▼
Cloud Claude Haiku (Fallback)
   │
   ▼
Audit-Log

Modell-Swaps ohne Claude Code neu zu starten; transparenter Fallback, wenn lokales Tool-Calling still scheitert; Request-Logs, die du grepen kannst, wenn etwas schiefgeht. Dasselbe Five-Contract-Pattern wie agent-approval-gate.

18. Wann lokale Modelle die falsche Wahl sind

• Repo-weite Refactors. Multi-Step-Tool-Flows kumulieren stille Tool-Call-Failures. Lokale Fine-Tunes verlieren schnell an Genauigkeit.
• Sicherheitskritische Edits ohne Approval-Gate. Nutze agent-approval-gate und die Lokal-vs-Cloud-Frage wird zweitrangig.
• Tool-lastige Sessions (50+ Tool-Calls). Jeder stille Failure kumuliert.
• Alles, was nach deiner Zeit abgerechnet wird. Ein gescheiterter lokaler Tool-Call kostet deine Zeit; ein erfolgreicher Haiku-Call kostet ungefähr $0,001.

Lokales Claude Code passt für: Chat-only-Assist auf privatem Code, Klassifikations-/Summarization-Sub-Steps, air-gapped Environments.

Quellen

• Ollama — Claude Code with Anthropic API compatibility (2026-01-16)
• LM Studio — Use your LM Studio Models in Claude Code (2026-01-30)
• vLLM — Claude Code integration docs
• Anthropic Claude Code documentation
• Anthropic Messages API reference
• LiteLLM Anthropic-compatible route docs
• Claude Code GitHub issue #7178 — local/self-hosted model support

Changelog

2026-04-29

• Deutsche Übersetzung der englischen Version.

2026-04-28

• TL;DR-Cheat-Sheet, “Empfohlenes Setup”, Smoke-Test, Debug-Flow, wiederverwendbares Startup-Skript, Hardware × Modell × Context × Backend-Tabelle ergänzt.
• Error-String-Sektion um <unused24> / <unused49>-Template-Leak-Symptome erweitert.
• 26B-A4B vs 31B-Vergleich ergänzt.
• “Setups, die ich vermeiden würde” ergänzt.
• Update-Log → Changelog umbenannt.
• Gemma-4-26B-A4B-Context-Empfehlungen ergänzt.
• MacBook Air vs Pro Presets ergänzt.
• 32K / 64K Claude-Code-Guidance ergänzt.
• Backend-Coverage neu geschrieben: Ollama, LM Studio, vLLM alle nativ Anthropic; llama.cpp als Apple-Silicon-Fast-Path ergänzt.
• LiteLLM als Fallback-Router (und OpenAI-Compat-Wrapper) repositioniert, nicht als Übersetzer.

2026-04-22

• Initialer Publish (Englisch).