So führen Sie DeepSeek V4 lokal aus

TR

Der praktikable Weg, DeepSeek V4 lokal auszuführen, besteht darin, die offiziellen Open-Source-Gewichte mit einem leistungsstarken Serving-Stack wie vLLM zu nutzen und das Modell anschließend über einen lokalen OpenAI-kompatiblen Endpunkt bereitzustellen. DeepSeeks aktuelle öffentliche Materialien beschreiben zwei Modelle der V4-Familie: DeepSeek-V4-Pro mit 1,6T Gesamtparametern / 49B aktiv und DeepSeek-V4-Flash mit 284B Gesamtparametern / 13B aktiv, beide mit 1M-Token-Kontext und drei Reasoning-Modi. Die aktuellen lokalen Deployment-Beispiele von vLLM zielen auf 8× B200/B300 für Pro und 4× B200/B300 für Flash. Wenn Sie nicht über entsprechende Hardware verfügen, ist ein gehosteter Fallback wie CometAPI der praktischere Weg.

DeepSeek AI sorgte am 24. April 2026 mit der Preview-Veröffentlichung von DeepSeek-V4 für Aufsehen, die zwei leistungsstarke Mixture-of-Experts-(MoE)-Modelle umfasst: DeepSeek-V4-Pro (1,6T Gesamtparameter, 49B aktiv) und DeepSeek-V4-Flash (284B gesamt, 13B aktiv). Beide unterstützen ein natives 1-Million-Token-Kontextfenster—ein Game-Changer für Langdokumentanalyse, agentische Workflows, Coding über massive Codebasen und Retrieval-Augmented Generation (RAG) im großen Maßstab.

Trainiert auf über 32 Billionen Tokens und mit Architekturinnovationen wie hybridem Compressed Sparse Attention (CSA) + Heavily Compressed Attention (HCA), manifold-konstrahierten Hyper-Verbindungen (mHC) und effizientem Speichermanagement erreicht V4 bis zu 73% Reduktion der Inferenz-FLOPs und 90% geringeren KV-Cache-Footprint für 1M-Kontexte im Vergleich zu V3.2. Die Performance rivalisiert mit Top-Closed-Source-Modellen, bleibt jedoch mit offenen Gewichten (MIT-Lizenz) verfügbar und ist über API extrem kosteneffizient.

Die Modelle lokal zu betreiben, bietet unschlagbare Privatsphäre, keine wiederkehrenden API-Kosten (abgesehen von Hardware), Offline-Fähigkeit und volle Anpassbarkeit. Ihre Größenordnung bringt jedoch Herausforderungen mit sich: Die vollständigen Gewichte von V4-Pro überschreiten 800 GB Downloadgröße, und die Inferenz erfordert erhebliche Hardware oder aggressive Quantisierung.

Kann DeepSeek V4 wirklich lokal laufen?

Ja, aber „lokal“ bedeutet hier etwas völlig anderes als das Ausführen eines 7B-Modells auf einem Laptop. DeepSeeks eigene Materialien und der vLLM-Support-Post verweisen auf große Multi-GPU-Systeme: V4-Pro ist ein 1,6T-Parameter-Modell mit 49B aktiven Parametern, während V4-Flash 284B gesamt / 13B aktiv besitzt. Die offiziellen Deployment-Beispiele von vLLM sind für 8× B200/B300 bei Pro und 4× B200/B300 bei Flash geschrieben. Das ist das klarste praktische Signal dafür, dass DeepSeek V4 ein lokales Deployment auf Enterprise-Niveau ist—kein beiläufiges Desktop-Experiment.

Dafür gibt es einen Grund: DeepSeek gibt an, dass V4 ein 1M-Token-Kontextfenster unterstützt, und der technische Bericht behauptet, dass V4-Pro nur 27% der Single-Token-Inferenz-FLOPs und 10% des KV-Caches im Vergleich zu DeepSeek-V3.2 bei 1M Kontext benötigt. vLLM führt weiter aus, dass DeepSeek V4 mit bf16 KV-Cache 9,62 GiB KV-Cache pro Sequenz bei 1M Kontext nutzt, was etwa 8,7× kleiner ist als die geschätzten 83,9 GiB für einen vergleichbaren Stack im Stil von DeepSeek-V3.2. Anders gesagt: V4 ist dramatisch effizienter als frühere Generationen, aber eine Million Token bleibt ein enormes Systemproblem.

Architektur-Vergleichstabelle: DeepSeek V4 vs. V3 und Wettbewerber

Das MoE-Design von V4 aktiviert pro Token nur einen Bruchteil der Parameter und hält den Rechenaufwand näher an einem dichten 13B–49B-Modell, während es vom Wissen eines deutlich größeren Netzwerks profitiert.

Welches DeepSeek V4-Modell sollten Sie verwenden?

Für die meisten lokalen Deployments ist DeepSeek-V4-Flash der bessere Ausgangspunkt. V4-Flash liefert bei einfacheren Agent-Aufgaben ein dem Pro-Modell eng angenähertes Reasoning, bleibt dabei jedoch schneller und wirtschaftlicher.

Verwenden Sie DeepSeek-V4-Pro, wenn absolute Leistungsfähigkeit wichtiger ist als Effizienz. Pro ist das stärkere Modell für schwierigere Reasoning-, Coding- und agentische Aufgaben. Die Benchmark-Tabellen zeigen warum: In der offiziellen Gegenüberstellung erreicht V4-Pro-Base 90.1 MMLU, 76.8 HumanEval und 51.5 LongBench-V2, während V4-Flash-Base 88.7, 69.5 und 44.7 erzielt. Beide sind stark; Pro legt einfach höher, wenn das bestmögliche Ergebnis gefragt ist.

Eine einfache Lesart der Tabelle genügt für die Produktplanung. Flash ist kein abgespecktes Spielzeugmodell; es ist ein ernstzunehmender Long-Context-Assistent mit geringeren Kosten. Pro ist das Modell, das Sie zuerst testen sollten, wenn das Problem schwierig, zustandsbehaftet oder nahe an einem produktiven Wissensworkflow liegt.

Empfohlener lokaler Stack

1) vLLM für produktionsnahes Serving

Die derzeit stärkste offizielle Option ist vLLM. Das vLLM-Team sagt, dass es jetzt die DeepSeek V4-Familie unterstützt und konkrete Single-Node-Startbefehle für beide Modelle bereitstellt. Ihr Beitrag ordnet V4 als Long-Context-Modellfamilie ein, die für Aufgaben bis zu einer Million Token ausgelegt ist, und beschreibt die Implementierungsarbeit für hybriden KV-Cache, Kernel-Fusion und disaggregiertes Serving.

Für V4-Pro zielt das vLLM-Beispiel auf 8× B200 oder 8× B300. Für V4-Flash zielt das Beispiel auf 4× B200 oder 4× B300. Die Befehle verwenden außerdem --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel sowie DeepSeek-spezifische Parsing-Flags wie --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 und --reasoning-parser deepseek_v4. Diese Kombination ist ein sehr deutlicher Hinweis darauf, wie DeepSeek ernsthaftes Self-Hosting erwartet.

# DeepSeek-V4-Flash on a supported multi-GPU hostdocker run --gpus all \  --ipc=host -p 8000:8000 \  -v ~/.cache/huggingface:/root/.cache/huggingface \  vllm/vllm-openai:deepseekv4-cu130 deepseek-ai/DeepSeek-V4-Flash \  --trust-remote-code \  --kv-cache-dtype fp8 \  --block-size 256 \  --enable-expert-parallel \  --data-parallel-size 4 \  --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE", "custom_ops":["all"]}' \  --attention_config.use_fp4_indexer_cache=True \  --tokenizer-mode deepseek_v4 \  --tool-call-parser deepseek_v4 \  --enable-auto-tool-choice \  --reasoning-parser deepseek_v4

Zum Wechsel auf V4-Pro behalten Sie dasselbe Muster bei und ändern das Modell auf deepseek-ai/DeepSeek-V4-Pro, wobei die Data-Parallel-Größe auf das Pro-Beispiel im vLLM-Post abgestimmt wird. Das ist der einfachste Weg, um lokal zu starten, ohne den Serving-Stack neu zu erfinden.

2) DeepSeeks Repository-Inferenz-Helfer

DeepSeek V4 enthält keine Jinja-Format-Chatvorlage. Stattdessen gibt es einen dedizierten encoding-Ordner mit Python-Skripten und Testfällen, um Nachrichten im OpenAI-Stil in Model-Input-Strings zu konvertieren und die Ausgabe zu parsen. Auf derselben Seite wird der inference-Ordner für Details zur lokalen Bereitstellung genannt, einschließlich Gewichtskonvertierung und interaktiven Chat-Demos. Das ist nützlich, wenn Sie ein benutzerdefiniertes Frontend bauen oder das Prompt-Formatting eng kontrollieren möchten.

3) CometAPI als praktikabler Backup-Plan

Wenn Sie keine B200/B300-Klasse-Hardware besitzen, ist ein gehosteter Weg die vernünftige Wahl. CometAPI sagt, es biete einen API-Schlüssel für alles, Zugriff auf 500+ KI-Modelle und Preise, die 20–40% günstiger sind als die offiziellen Anbieterpreise. Es veröffentlicht zudem dedizierte DeepSeek V4-Seiten, einschließlich DeepSeek-V4-Pro und DeepSeek-V4-Flash, mit OpenAI-kompatiblen Integrationsbeispielen.

Schritt-für-Schritt: So führen Sie DeepSeek V4 lokal aus

1. Voraussetzungen

• OS: Bevorzugt Linux (Ubuntu 22.04/24.04) für die beste CUDA/ROCm-Unterstützung. Windows via WSL2 oder nativ. macOS mit Metal (für die größten Modelle eingeschränkt).
• Treiber: NVIDIA CUDA 12.4+ (oder aktueller). AMD ROCm für Radeon-Karten.
• Python 3.11+, Git und ausreichend Speicherplatz.
• Hugging Face-Konto für geschützte Modelle (falls zutreffend): huggingface-cli login.

2. Der einfachste Weg: Ollama oder LM Studio (Einsteigerfreundlich)

Ollama bietet das einfachste CLI- und WebUI-Erlebnis. Stand Ende April 2026 kann volle V4-Unterstützung benutzerdefinierte Modelfiles oder Community-Tags erfordern, aber quantisierte V4-Flash-Versionen verbreiten sich schnell.

Ollama installieren (Linux/macOS):

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

Kompatibles Modell ausführen (mit kleineren beginnen oder nach V4-Tags suchen):

ollama pull deepseek-v4-flash:q4_0   # Example quantized tag; check ollama.com/library or community
ollama run deepseek-v4-flash:q4_0

Für benutzerdefiniert: Modelfile erstellen (Text):

FROM ./DeepSeek-V4-Flash-GGUF-Q4.gguf
TEMPLATE """{{ .Prompt }}"""
PARAMETER num_ctx 32768  # Start conservative; increase as hardware allows up to 1M with sufficient RAM/VRAM

Dann ollama create my-v4-flash -f Modelfile.

LM Studio: GUI-Alternative. Von lmstudio.ai herunterladen, bei HF nach DeepSeek-V4-GGUF-Quantisierungen (TheBloke-Style oder offiziell) suchen/browsen, laden und chatten. Hervorragend zum Experimentieren mit Kontext-Slidern und GPU-Offloading.

Open WebUI: Als Schicht über Ollama für eine ChatGPT-ähnliche Oberfläche (Bash):

docker run -d -p 8080:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Zugriff unter http://localhost:8080.

3. Fortgeschritten: Hugging Face + vLLM oder SGLang (Höchstleistung)

Für maximale Geschwindigkeit und 1M-Kontextunterstützung verwenden Sie vLLM (exzellente MoE- und PagedAttention-Unterstützung):

Schritt 1: Umgebung vorbereiten

Installieren Sie den aktuellen vLLM-Stack und stellen Sie sicher, dass CUDA, Treiber und GPU-Topologie zum Zielmodell passen. recommending temperature = 1.0 and top_p = 1.0 for local deployment, and for Think Max it recommends a context window of at least 384K tokens. Das ist ein nützlicher Ausgangspunkt, egal ob Sie eine Chat-App, einen Coding-Assistenten oder einen Agent-Workflow aufbauen.

Installation:

Bash
pip install -U "vllm>=0.9.0"  # Check latest for V4 compatibility

Modell herunterladen (CLI für große Dateien verwenden):

Bash
pip install -U "huggingface_hub[cli]"
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./DeepSeek-V4-Flash

Mit vLLM serven (Beispiel für Flash auf 2 GPUs):

Schritt 2: Modellserver starten

Sobald der Container läuft, exponieren Sie das Modell als OpenAI-kompatiblen lokalen Endpunkt. Dadurch können Sie Ihren bestehenden Anwendungscode wiederverwenden und Backends austauschen, ohne die App-Architektur zu ändern.

Mit vLLM serven (Beispiel für Flash auf 2 GPUs):

Python
from vllm import LLM, SamplingParams

llm = LLM(
    model="deepseek-ai/DeepSeek-V4-Flash",
    tensor_parallel_size=2,      # Adjust to your GPU count
    max_model_len=1048576,       # 1M context (hardware permitting)
    dtype="auto",                # or "fp8" / "bfloat16"
    quantization="gptq" if using quantized weights else None,
    gpu_memory_utilization=0.9
)

sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=4096)

outputs = llm.generate(["Explain the architecture of DeepSeek V4 in detail."], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

Für den Servermodus (OpenAI-kompatible API):

Bash
vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --port 8000

Dann per OpenAI-Client abfragen, indem base_url="http://localhost:8000/v1" gesetzt wird.

SGLang-Alternative für potenziell bessere Long-Context-Performance:

Bash
pip install "sglang[all]>=0.4.0"
python -m sglang.launch_server --model-path deepseek-ai/DeepSeek-V4-Flash --port 30000

Schritt 3: Den lokalen Endpunkt aus Python abfragen

from openai import OpenAI
# Adjust the base URL if your vLLM server is bound differently.

client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY",
)

response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-V4-Flash",
messages=[
{"role": "system", "content": "You are a precise, technical assistant."},
{"role": "user", "content": "Explain the difference between V4-Pro and V4-Flash."},
],
temperature=1.0,
top_p=1.0,
)

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

Leistungserwartungen und Optimierungstipps

• Tokens/s: Auf einer RTX 4090 mit Q4 Flash: 15–40+ T/s bei 8K–32K Kontext (je nach Implementierung). Fällt bei 128K+ aufgrund von Attention/KV, aber V4-Optimierungen helfen. Multi-GPU skaliert gut mit Tensor-/Pipeline-Parallelisierung.
• Optimierungen:
• FlashAttention-3 oder vLLMs PagedAttention nutzen.
• Spekulatives Decoding für 1,5–2× Speedup.
• Kontext-Pruning oder -Kompressionstechniken.
• Mit nvidia-smi monitoren; gpu_memory_utilization nutzen.
• Für CPU: llama.cpp mit --n-gpu-layers -1 (alles offladen, wenn möglich) oder reine CPU mit viel RAM.

Benchmarken Sie Ihr Setup mit Tools wie llama-bench oder einfachen Timing-Skripten. Der reale Durchsatz hängt von Promptlänge, Generationslänge und Hardware ab.

Herausforderungen und Einschränkungen beim lokalen V4-Deployment

• Ressourcenintensität: Selbst Flash erfordert ordentliche Hardware für komfortable Geschwindigkeiten bei langen Kontexten.
• Quantisierungs-Trade-offs: Niedrigere Bitbreiten können die Reasoning-Qualität reduzieren, insbesondere bei komplexen Aufgaben—validieren Sie mit Benchmarks wie SWE-Bench, MMLU oder Ihren domänenspezifischen Evaluierungen.
• Software-Reifegrad: Als neue Preview (April 2026) rollt die voll optimierte Unterstützung in allen Backends gerade aus. Prüfen Sie GitHub-Issues für vLLM, llama.cpp und HF.
• Download/Speicher: Terabyte-Modelle benötigen schnelles Internet und Speicher.
• Strom & Wärme: High-End-Setups verbrauchen signifikant Strom.

Für viele Nutzer funktionieren hybride Ansätze am besten: Kleinere Aufgaben lokal ausführen, schwere 1M-Kontext-Reasoning-Aufgaben bei Bedarf in die Cloud auslagern.

Wenn lokal nicht reicht: Nahtlose Integration mit CometAPI

Für viele Teams ist es am klügsten, ein lokales Deployment gar nicht zu erzwingen. Während lokales Deployment bei Privatsphäre und Kontrolle glänzt, sprechen Skalierung in die Produktion, Spitzenlasten oder Zugriff auf volle unquantisierte Performance ohne massive Hardwareinvestition oft für eine verlässliche API.

CometAPI bietet ein einheitliches, OpenAI-kompatibles Gateway zu DeepSeek-Modellen—einschließlich der neuesten Deeppseek V4-Serie—sowie Dutzenden anderer Top-LLMs (Claude, GPT, Llama, Qwen, Grok usw.).

Wo die API der lokalen Bereitstellung überlegen ist

Die aktuellen DeepSeek V4-Modelle sind über OpenAI- und Anthropic-Style-Endpunkte verfügbar, mit Basis-URLs, die stabil bleiben, während sich der Modellname ändert. Die Dokumentation sagt außerdem, dass die Modellnamen deepseek-chat und deepseek-reasoner schließlich auslaufen und während der Transition auf V4-Flash-Verhalten abbilden.

Das ist wichtig, weil lokales Deployment Betriebskosten mit sich bringt. Wenn die Arbeitslast nicht sensibel für Datenresidenz ist oder Ihr Team schneller Wert liefern möchte, ist der API-Weg meist die rationale Wahl. V4-Flash zu $0.14 pro 1M Eingabetoken bei Cache-Miss, $0.0028 pro 1M Eingabetoken bei Cache-Hit und $0.28 pro 1M Ausgabetoken. Auf derselben Seite heißt es, dass V4-Pro derzeit bis zum 31. Mai 2026 um 75% rabattiert ist, bei $0.435 pro 1M Eingabetoken bei Cache-Miss und $0.87 pro 1M Ausgabetoken.

DeepSeeks beste Alternative: Wo CometAPI passt

CometAPI ist nützlich, wenn das Ziel nicht nur ein einmaliger Aufruf von DeepSeek V4 ist, sondern der Aufbau eines Stacks, der Modelle schnell wechseln kann. CometAPI gibt an, einen API-Schlüssel für 500+ Modelle, eine OpenAI-kompatible API, Nutzungsanalysen und niedrigere Preise als offizielle Anbieter zu bieten. Es positioniert sich außerdem als Mittel, um Vendor-Lock-in zu vermeiden und Ausgaben über mehrere Anbieter zu managen.

Das macht CometAPI zu einer starken Empfehlung für Teams, die V4-Pro gegen V4-Flash evaluieren oder DeepSeek gegen andere Frontier-Modelle in derselben Anwendung vergleichen. Anstatt bei jedem Modellwechsel eine neue Integration zu verdrahten, kann die Anwendung einen stabilen OpenAI-Style-Client behalten und nur den Wert von model und die Base-URL wechseln. CometAPIs V4-Leitfaden zeigt genau dieses Muster.

Schnellstart mit CometAPI für DeepSeek V4:

• OpenAI SDK verwenden:
• Registrieren/Anmelden unter CometAPI.com.
• Einen API-Schlüssel in der Konsole generieren.

Hier ist die gehostete Version desselben Integrationsmusters:

from openai import OpenAIclient = OpenAI(    base_url="https://api.cometapi.com",    api_key="YOUR_COMETAPI_KEY",)response = client.chat.completions.create(    model="deepseek-v4-pro",    messages=[        {"role": "system", "content": "You are a senior coding assistant."},        {"role": "user", "content": "Review this architecture for bottlenecks."}    ],    stream=False,    extra_body={        "thinking": {"type": "enabled"},        "reasoning_effort": "high"    })print(response.choices[0].message.content)

Der Wert dieses Weges ist operativ, nicht rhetorisch. Er eliminiert Infrastrukturarbeit, hält den Client-Code portabel und gibt dem Team einen zentralen Ort, um Kosten, Latenz und Qualität über mehrere Modelle zu testen. CometAPI sagt außerdem, dass es Ausgaben, Latenz und Aufrufvolumen nachverfolgt—nützlich, sobald der Prototyp zur Produktionslast wird.

Wann lokal, API oder CometAPI wählen

Der lokale Weg ist gerechtfertigt, wenn Kontrolle wichtiger ist als Bequemlichkeit. Der API-Weg ist gerechtfertigt, wenn Geschwindigkeit und Einfachheit wichtiger sind als Eigentümerschaft. CometAPI ist die mittlere Schicht, wenn das Team Portabilität und Kostendisziplin will, ohne die Integration bei jedem Modellwechsel neu zu bauen.

FAQ

Kann DeepSeek V4 auf einem Laptop laufen?

Nicht in dem praktischen Sinn, den lokale Inferenz-Tutorials suggerieren. Die offiziellen Materialien verweisen auf Multi-GPU- und Multi-Node-Deployment, und die Modellgrößen gehen weit über die gewöhnlichen Speicherkapazitäten von Consumer-Geräten hinaus. Ein Laptop ist für API-Zugriff in Ordnung, aber nicht für sinnvolles Self-Hosting von V4-Pro oder auch nur ein komfortables V4-Flash-Setup.

Was ist besser: V4-Pro oder V4-Flash?

V4-Pro ist das stärkere Modell für Reasoning, Coding und Forschung. V4-Flash ist die bessere Standardeinstellung für Geschwindigkeit, Durchsatz und geringere Kosten. Die offizielle Veröffentlichung und die Benchmark-Tabelle führen zur selben Schlussfolgerung.

Ist CometAPI für lokales Deployment erforderlich?

Nein. Es ist eine optionale Produktionsschicht. DeepSeeks eigene API funktioniert direkt, und lokales Self-Hosting ist über den offiziellen Inferenzpfad möglich. CometAPI wird attraktiv, wenn Sie einen Codepfad über viele Modellanbieter hinweg, Kostenverfolgung und einfacheres Umschalten zwischen Modellfamilien wünschen.

Fazit

DeepSeek V4 ist nicht nur eine weitere Modellveröffentlichung. Es ist ein Long-Context-, agentenfokussiertes System mit offenen Gewichten, offiziellem API-Zugang und einer klaren Aufteilung zwischen einem hochperformanten Reasoning-Modell und einem kostengünstigeren Durchsatz-Modell. Die neuesten offiziellen Neuigkeiten sind wichtig, weil sie den Entscheidungsbaum verändern: Lokales Deployment ist möglich, aber nur für Teams mit ernsthafter GPU-Infrastruktur; API-Zugang ist sofort verfügbar; und CometAPI ist eine sinnvolle Empfehlung, wenn Portabilität und Kostendisziplin wichtiger sind als der Besitz des Inferenz-Stacks.

Wenn die Arbeitslast komplex ist und die Hardware vorhanden, beginnen Sie mit V4-Pro. Wenn die Arbeitslast volumengetrieben ist, beginnen Sie mit V4-Flash. Wenn das Ziel ist, schnell zu liefern und Modelloptionen offen zu halten, verwenden Sie die API-Schicht und halten Sie Ihren Code portabel. Das ist derzeit die am besten vertretbare Produktionsstrategie.

Konkrete nächste Schritte:

1. Evaluieren Sie Ihre Hardware und starten Sie mit quantisiertem V4-Flash über Ollama oder LM Studio.
2. Experimentieren Sie mit den obigen Codebeispielen und benchmarken Sie gegen Ihre Workloads.
3. Erkunden Sie GGUF-Quantisierungen und Community-Optimierungen, sobald sie nach der Veröffentlichung reifen.
4. Integrieren Sie für Produktion oder schwere Lasten CometAPI für zuverlässigen, kosteneffizienten Zugriff auf vollwertiges V4-Pro/Flash, ohne Hardware zu managen.