Cara Menjalankan DeepSeek V4 Secara Lokal

TR

Cara praktis menjalankan DeepSeek V4 secara lokal adalah menggunakan bobot open-source resmi dengan tumpukan penyajian berperforma tinggi seperti vLLM, lalu mengekspos model melalui endpoint lokal yang kompatibel dengan OpenAI. Materi publik DeepSeek saat ini menjelaskan dua model dalam keluarga V4: DeepSeek-V4-Pro dengan 1,6T total parameter / 49B aktif, dan DeepSeek-V4-Flash dengan 284B total parameter / 13B aktif, keduanya dengan konteks 1M token dan tiga mode penalaran. Contoh penerapan lokal vLLM saat ini menargetkan 8× B200/B300 untuk Pro dan 4× B200/B300 untuk Flash. Jika Anda tidak memiliki perangkat keras seperti itu, layanan terkelola seperti CometAPI lebih praktis.

DeepSeek AI merilis kabar besar pada 24 April 2026 dengan pratinjau DeepSeek-V4, menampilkan dua model Mixture-of-Experts (MoE) yang kuat: DeepSeek-V4-Pro (1,6T total parameter, 49B aktif) dan DeepSeek-V4-Flash (284B total, 13B aktif). Keduanya mendukung jendela konteks native 1 juta token—pengubah permainan untuk analisis dokumen panjang, alur kerja agen, coding pada basis kode masif, dan retrieval-augmented generation (RAG) skala besar.

Dilatih pada lebih dari 32 triliun token dengan inovasi arsitektur seperti hybrid Compressed Sparse Attention (CSA) + Heavily Compressed Attention (HCA), manifold-constrained hyper-connections (mHC), dan penanganan memori efisien, V4 mencapai pengurangan FLOPs inferensi hingga 73% dan jejak KV cache 90% lebih rendah untuk konteks 1M dibandingkan V3.2. Kinerjanya menyaingi model closed-source teratas sambil tetap open-weights (lisensi MIT) dan sangat hemat biaya melalui API.

Menjalankan model ini secara lokal menawarkan privasi tak tertandingi, tanpa biaya API berulang (di luar perangkat keras), kemampuan offline, dan kustomisasi penuh. Namun, skalanya menghadirkan tantangan: bobot penuh V4-Pro melampaui unduhan 800GB, dan inferensi menuntut perangkat keras signifikan atau kuantisasi agresif.

Apakah DeepSeek V4 benar-benar bisa dijalankan secara lokal?

Bisa, tetapi “lokal” di sini sangat berbeda dari menjalankan model 7B di laptop. Materi DeepSeek dan posting dukungan vLLM menunjuk ke sistem multi-GPU besar: V4-Pro adalah model 1,6T parameter dengan 49B parameter aktif, sementara V4-Flash adalah 284B total / 13B aktif. Contoh penerapan resmi dari vLLM ditulis untuk 8× B200/B300 pada Pro dan 4× B200/B300 pada Flash. Itulah sinyal praktis paling jelas bahwa DeepSeek V4 adalah penerapan lokal kelas enterprise, bukan eksperimen desktop kasual.

Ada alasan untuk skala tersebut. DeepSeek mengatakan V4 mendukung jendela konteks 1M token, dan laporan teknis menyatakan V4-Pro hanya menggunakan 27% FLOPs inferensi per token dan 10% KV cache dibandingkan DeepSeek-V3.2 pada konteks 1M. vLLM lebih lanjut menjelaskan bahwa, dengan bf16 KV cache, DeepSeek V4 menggunakan 9,62 GiB KV cache per sequence pada konteks 1M, sekitar 8,7× lebih kecil daripada estimasi 83,9 GiB untuk tumpukan gaya DeepSeek-V3.2 yang sebanding. Dengan kata lain, V4 jauh lebih efisien daripada generasi sebelumnya, tetapi satu juta token tetap merupakan masalah sistem yang sangat besar.

Tabel Perbandingan Arsitektur: DeepSeek V4 vs V3 dan Kompetitor

Desain MoE V4 mengaktifkan hanya sebagian parameter per token, menjaga komputasi mendekati model dense 13B-49B sambil memanfaatkan pengetahuan jaringan yang jauh lebih besar.

Model Deepseek V4 mana yang harus Anda gunakan?

Untuk sebagian besar penerapan lokal, DeepSeek-V4-Flash adalah titik awal yang lebih baik. V4-Flash menghadirkan penalaran yang mendekati Pro pada tugas agen yang lebih sederhana sekaligus tetap lebih cepat dan lebih ekonomis.

Gunakan DeepSeek-V4-Pro jika Anda lebih mementingkan kapabilitas absolut daripada efisiensi. Pro lebih kuat untuk penalaran yang sulit, coding, dan tugas agen. Tabel tolok ukur menunjukkan alasannya: pada perbandingan resmi, V4-Pro-Base mencapai 90.1 MMLU, 76.8 HumanEval, dan 51.5 LongBench-V2, sedangkan V4-Flash-Base mencetak 88.7, 69.5, dan 44.7. Keduanya kuat; Pro melaju lebih tinggi ketika Anda membutuhkan hasil terbaik.

Pembacaan sederhana terhadap tabel sudah cukup untuk perencanaan produk. Flash bukan model ringan yang dipangkas; ini adalah asisten long-context yang serius dengan biaya lebih rendah. Pro adalah model pertama yang diuji ketika masalahnya sulit, stateful, atau dekat dengan alur kerja pengetahuan produksi.

Rekomendasi tumpukan lokal

1) vLLM untuk serving bergaya produksi

Opsi resmi terkuat saat ini adalah vLLM. Tim vLLM mengatakan kini mendukung keluarga DeepSeek V4 dan menyediakan perintah peluncuran single-node konkret untuk kedua model. Postingan mereka membingkai V4 sebagai keluarga model long-context yang dirancang untuk tugas hingga satu juta token dan menjelaskan pekerjaan implementasi yang diperlukan untuk hybrid KV cache, kernel fusion, dan disaggregated serving.

Untuk V4-Pro, contoh vLLM menargetkan 8× B200 atau 8× B300. Untuk V4-Flash, contoh menargetkan 4× B200 atau 4× B300. Perintah juga menggunakan --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel, dan flag parsing khusus DeepSeek seperti --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4, dan --reasoning-parser deepseek_v4. Kombinasi ini adalah petunjuk kuat tentang bagaimana DeepSeek mengharapkan self-hosting serius dilakukan.

# 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

Untuk beralih ke V4-Pro, pertahankan pola yang sama dan ubah model menjadi deepseek-ai/DeepSeek-V4-Pro, dengan ukuran data-parallel dipindahkan ke contoh Pro pada posting vLLM. Itu cara paling sederhana untuk mulai menguji secara lokal tanpa menciptakan ulang tumpukan serving.

2) Alat bantu inferensi dari repositori DeepSeek

Deepseek V4 tidak menyertakan template chat format Jinja. Sebagai gantinya, ia menyediakan folder encoding khusus dengan skrip Python dan test case untuk mengonversi pesan gaya OpenAI menjadi string input model dan mem-parsing output. Halaman yang sama mengatakan untuk melihat folder inference untuk detail penerapan lokal, termasuk konversi bobot dan demo chat interaktif. Ini berguna jika Anda ingin membangun front end kustom atau mengontrol ketat pemformatan prompt.

3) CometAPI sebagai rencana cadangan praktis

Jika Anda tidak memiliki perangkat keras kelas B200/B300, rute hosted adalah pilihan yang masuk akal. CometAPI mengatakan menawarkan satu kunci API untuk semuanya, akses ke 500+ model AI, dan harga yang 20–40% lebih murah daripada tarif vendor resmi. Mereka juga memublikasikan halaman DeepSeek V4 khusus, termasuk DeepSeek-V4-Pro dan DeepSeek-V4-Flash, dengan contoh integrasi kompatibel OpenAI.

Langkah demi Langkah: Cara Menjalankan DeepSeek V4 Secara Lokal

1. Prasyarat

• OS: Linux (Ubuntu 22.04/24.04) disarankan untuk dukungan CUDA/ROCm terbaik. Windows via WSL2 atau native. macOS dengan Metal (terbatas untuk model terbesar).
• Driver: NVIDIA CUDA 12.4+ (atau terbaru). AMD ROCm untuk kartu Radeon.
• Python 3.11+, Git, dan ruang disk yang memadai.
• Akun Hugging Face untuk model berpagar (jika berlaku): huggingface-cli login.

2. Cara Termudah: Ollama atau LM Studio (Ramah Pemula)

Ollama menyediakan pengalaman CLI dan WebUI paling sederhana. Per akhir April 2026, dukungan penuh V4 mungkin memerlukan Modelfile kustom atau tag komunitas, tetapi versi V4-Flash terkuantisasi bermunculan cepat.

Instal Ollama (Linux/macOS):

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

Jalankan model yang kompatibel (mulai dari yang lebih kecil atau cek tag V4):

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

Untuk kustom: Buat Modelfile (teks):

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

Kemudian jalankan ollama create my-v4-flash -f Modelfile.

LM Studio: Alternatif GUI. Unduh dari lmstudio.ai, cari/jelajahi HF untuk kuantisasi DeepSeek-V4 GGUF (gaya TheBloke atau resmi), muat, dan chat. Sangat baik untuk eksperimen dengan slider konteks dan offloading GPU.

Open WebUI: Lapisan di atas Ollama untuk antarmuka seperti ChatGPT (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

Akses di http://localhost:8080.

3. Lanjutan: Hugging Face + vLLM atau SGLang (Performa Tinggi)

Untuk kecepatan maksimum dan dukungan konteks 1M, gunakan vLLM (dukungan MoE dan PagedAttention sangat baik):

Langkah 1: Siapkan lingkungan

Mulailah dengan menginstal stack vLLM terkini dan pastikan CUDA, driver, dan topologi GPU Anda cocok dengan model yang ingin dijalankan. merekomendasikan temperature = 1.0 dan top_p = 1.0 untuk penerapan lokal, dan untuk Think Max merekomendasikan jendela konteks minimal 384K token. Ini titik awal yang berguna baik Anda membangun aplikasi chat, asisten coding, atau alur kerja agen.

Instalasi:

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

Unduh model (gunakan CLI untuk file besar):

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

Serve dengan vLLM (contoh untuk Flash pada 2 GPU):

Langkah 2: Luncurkan server model

Setelah kontainer aktif, ekspos model sebagai endpoint lokal yang kompatibel dengan OpenAI. Ini memudahkan Anda memakai ulang kode aplikasi yang ada dan menukar backend tanpa mengubah arsitektur aplikasi.

Serve dengan vLLM (contoh untuk Flash pada 2 GPU):

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)

Untuk mode server (API kompatibel OpenAI):

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

Lalu query lewat klien OpenAI dengan mengatur base_url="http://localhost:8000/v1".

SGLang alternatif untuk kinerja long-context yang berpotensi lebih baik:

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

Langkah 3: Query endpoint lokal dari Python

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)

Ekspektasi Kinerja dan Tips Optimasi

• Token/detik: Pada RTX 4090 dengan Q4 Flash: 15–40+ t/s di konteks 8K–32K (tergantung implementasi). Turun pada 128K+ karena attention/KV tetapi efisiensi V4 membantu. Multi-GPU menskalakan dengan baik dengan tensor/pipeline parallelism.
• Optimasi:
• Gunakan FlashAttention-3 atau PagedAttention milik vLLM.
• Speculative decoding untuk peningkatan kecepatan 1,5–2×.
• Teknik pruning atau kompresi konteks.
• Pantau dengan nvidia-smi; manfaatkan gpu_memory_utilization.
• Untuk CPU: llama.cpp dengan --n-gpu-layers -1 (semua offload jika memungkinkan) atau CPU murni dengan RAM tinggi.

Benchmark setup Anda dengan alat seperti llama-bench atau skrip timing sederhana. Throughput nyata bergantung pada panjang prompt, panjang generasi, dan perangkat keras.

Tantangan dan Keterbatasan Penerapan V4 Lokal

• Intensif sumber daya: Bahkan Flash memerlukan perangkat keras yang layak untuk kecepatan nyaman pada konteks panjang.
• Trade-off kuantisasi: Bit lebih rendah dapat menurunkan kualitas penalaran, terutama pada tugas kompleks—validasi dengan tolok ukur seperti SWE-Bench, MMLU, atau evaluasi domain Anda.
• Kematangan perangkat lunak: Sebagai pratinjau baru (April 2026), dukungan yang sepenuhnya dioptimalkan di semua backend sedang digulirkan. Periksa issue GitHub untuk vLLM, llama.cpp, dan HF.
• Unduhan/Penyimpanan: Model skala terabyte memerlukan internet dan penyimpanan cepat.
• Daya & panas: Setup kelas atas mengonsumsi listrik signifikan.

Bagi banyak pengguna, pendekatan hibrida paling efektif: Jalankan tugas kecil secara lokal, alihkan penalaran konteks 1M yang berat ke cloud bila diperlukan.

Ketika Lokal Tidak Cukup: Integrasi Mulus dengan CometAPI

Bagi banyak tim, langkah paling cerdas adalah tidak memaksakan penerapan lokal sama sekali. Sementara penerapan lokal unggul untuk privasi dan kontrol, penskalaan ke produksi, menangani lonjakan beban, atau mengakses kinerja penuh tanpa investasi perangkat keras masif sering kali lebih baik melalui API yang andal.

CometAPI menyediakan gateway terpadu yang kompatibel dengan OpenAI ke model DeepSeek—termasuk seri Deeppseek V4 terbaru—bersama puluhan LLM top lainnya (Claude, GPT, Llama, Qwen, Grok, dll.).

Saat API mengungguli penerapan lokal

Model Deepseek V4 saat ini tersedia melalui endpoint gaya OpenAI dan gaya Anthropic, dengan base URL yang tetap stabil sementara nama model berubah. Dokumentasi juga menyatakan nama model deepseek-chat dan deepseek-reasoner pada akhirnya akan didepresiasi dan dipetakan ke perilaku V4-Flash selama masa transisi.

Itu penting karena penerapan lokal membawa biaya operasional. Jika beban kerja tidak sensitif terhadap residensi data atau tim Anda ingin time-to-value yang lebih cepat, rute API biasanya pilihan rasional. V4-Flash di $0.14 per 1M input token saat cache miss, $0.0028 per 1M input token saat cache hit, dan $0.28 per 1M output token. Halaman yang sama menyatakan V4-Pro saat ini didiskon 75% hingga 31 Mei 2026, pada $0.435 per 1M input token saat cache miss dan $0.87 per 1M output token.

Alternatif terbaik untuk Deepseek: Di mana CometAPI cocok

CometAPI berguna ketika tujuannya bukan hanya memanggil DeepSeek V4 sekali, tetapi membangun tumpukan yang dapat beralih model dengan cepat. CometAPI mengatakan menyediakan satu kunci API untuk 500+ model, API kompatibel OpenAI, analitik penggunaan, dan harga lebih rendah daripada tarif vendor resmi. Ia juga memosisikan diri sebagai cara untuk menghindari lock-in vendor dan mengelola pengeluaran di berbagai penyedia.

Ini membuat CometAPI menjadi rekomendasi kuat bagi tim yang mengevaluasi V4-Pro melawan V4-Flash, atau membandingkan DeepSeek dengan model frontier lain dalam aplikasi yang sama. Alih-alih menyambungkan integrasi baru setiap kali model berubah, aplikasi dapat mempertahankan klien gaya OpenAI yang stabil dan hanya mengganti nilai model dan base URL. Panduan V4 CometAPI menunjukkan pola tersebut secara tepat.

Quick Start dengan CometAPI untuk DeepSeek V4:

• Gunakan SDK OpenAI:
• Daftar/masuk di CometAPI.com.
• Buat kunci API di konsol.

Berikut versi hosted dari pola integrasi yang sama:

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)

Nilai dari rute ini bersifat operasional, bukan retoris. Ini menghapus pekerjaan infrastruktur, menjaga kode klien tetap portabel, dan memberi tim satu tempat untuk menguji biaya, latensi, dan kualitas di berbagai model. CometAPI juga mengatakan melacak pengeluaran, latensi, dan volume panggilan, yang berguna ketika prototipe menjadi beban kerja produksi.

Kapan memilih lokal, API, atau CometAPI

Jalur lokal dibenarkan ketika kontrol lebih penting daripada kenyamanan. Jalur API dibenarkan ketika kecepatan dan kesederhanaan lebih penting daripada kepemilikan. CometAPI adalah lapisan tengah ketika tim menginginkan portabilitas dan disiplin biaya tanpa membangun ulang integrasi setiap kali model berubah.

FAQ

Bisakah DeepSeek V4 dijalankan di laptop?

Tidak dalam arti praktis yang diimplikasikan oleh tutorial inferensi lokal. Materi resmi menunjuk pada penerapan multi-GPU dan multi-node, dan ukuran model jauh melampaui anggaran memori konsumen biasa. Laptop baik untuk akses API, tetapi tidak untuk self-hosting V4-Pro yang bermakna atau bahkan setup V4-Flash yang nyaman.

Mana yang lebih baik: V4-Pro atau V4-Flash?

V4-Pro lebih kuat untuk penalaran, coding, dan riset. V4-Flash adalah default yang lebih baik untuk kecepatan, throughput, dan biaya lebih rendah. Rilis resmi dan tabel tolok ukur mengarah pada kesimpulan yang sama.

Apakah CometAPI diperlukan dalam penerapan lokal?

Tidak. Ini adalah lapisan produksi opsional. API DeepSeek sendiri dapat digunakan langsung, dan self-hosting lokal dimungkinkan melalui jalur inferensi resmi. CometAPI menjadi menarik ketika Anda menginginkan satu jalur kode untuk banyak penyedia model, pelacakan biaya, dan peralihan model yang lebih mudah.

Kesimpulan

DeepSeek V4 bukan sekadar rilis model lainnya. Ini adalah sistem berfokus agen dengan long-context, open weights, akses API resmi, dan pemisahan jelas antara model penalaran kelas atas dan model throughput berbiaya lebih rendah. Berita resmi terbaru penting karena mengubah pohon keputusan: penerapan lokal memungkinkan, tetapi hanya untuk tim dengan infrastruktur GPU serius; akses API tersedia segera; dan CometAPI merupakan rekomendasi masuk akal ketika portabilitas dan disiplin biaya lebih penting daripada memiliki tumpukan inferensi.

Jika beban kerja kompleks dan perangkat keras tersedia, mulai dengan V4-Pro. Jika beban kerja didorong volume, mulai dengan V4-Flash. Jika tujuannya adalah meluncurkan cepat dan menjaga opsi model tetap terbuka, gunakan lapisan API dan buat kode Anda portabel. Itulah strategi produksi paling defensif saat ini.

Langkah Tindak Lanjut yang Dapat Dilakukan:

1. Nilai perangkat keras Anda dan mulai dengan V4-Flash terkuantisasi melalui Ollama atau LM Studio.
2. Bereksperimen dengan contoh kode di atas dan benchmark terhadap beban kerja Anda.
3. Jelajahi kuantisasi GGUF dan optimasi komunitas seiring matang pasca-rilis.
4. Untuk produksi atau pekerjaan berat, integrasikan CometAPI untuk akses andal dan hemat biaya ke V4-Pro/Flash penuh tanpa mengelola perangkat keras.