Bangun dengan CometAPIButuh satu API untuk banyak model?Uji alur kerja di Playground, lalu buat API key saat model dan biayanya sesuai dengan use case Anda.
Cara Menjalankan DeepSeek-V3.1 di perangkat lokal Anda - CometAPI
Cara Menjalankan DeepSeek-V3.1 di perangkat lokal Anda
DeepSeek-V3.1 adalah model obrolan Campuran-Pakar (MoE) hibrida yang dirilis oleh DeepSeek pada bulan Agustus 2025 yang mendukung dua mode inferensi — “non-berpikir” yang cepat
DeepSeek-V3.1 adalah model obrolan Campuran-Pakar (MoE) hibrida yang dirilis oleh DeepSeek pada bulan Agustus 2025 yang mendukung dua mode inferensi — mode "non-berpikir" yang cepat dan mode "berpikir" yang disengaja — dari titik pemeriksaan yang sama. Model ini tersedia di Hugging Face dan dapat dijalankan secara lokal melalui beberapa jalur (vLLM, Ollama/llama.cpp, GGUF bergaya Ollama, atau pengaturan multi-GPU skala besar). Di bawah ini saya akan memandu Anda melalui persyaratan, cara kerja mode berpikir, beberapa opsi eksekusi lokal (dengan cuplikan kode yang dapat dijalankan), dan resep "penerapan Mode Berpikir" langkah demi langkah beserta contoh pemanggilan alat dan templat token.
Apa itu DeepSeek-V3.1 dan mengapa itu penting?
DeepSeek-V3.1 adalah pembaruan keluarga v3 dari DeepSeek yang memperkenalkan : model yang sama dapat dijalankan di (deliberatif, multi-langkah) atau (jawaban langsung, lebih cepat) dengan mengubah templat obrolan. Secara arsitektur, ini merupakan keluarga MoE yang besar (titik pemeriksaan dasar sekitar 671 miliar parameter total, ~37 miliar diaktifkan per token) dengan pelatihan konteks panjang yang diperluas hingga 128 ribu token dan dukungan penskalaan mikro FP8. DeepSeek memposisikan V3.1 sebagai rilis yang siap untuk agen: pemanggilan alat yang lebih baik, peningkatan keterampilan agen, dan efisiensi berpikir yang lebih tinggi dibandingkan rilis R1 sebelumnya. Rilis ini diumumkan pada Agustus 2025 dan telah diintegrasikan ke dalam Hugging Face, perkakas CFD/OSS, dan panduan penerapan cloud.
Ditinjau untuk kejelasan, atribusi sumber, dan terminologi API terkini.
desain inferensi hibrida
pikir
tidak berpikir
Cara kerja model hibrida (ringkas)
Satu pos pemeriksaan, dua templat: Mode Berpikir vs Non-Berpikir dikendalikan oleh templat obrolan dan <think>/</think> Konvensi token dalam prompt. Kartu model mendokumentasikan awalan yang tepat.
Peningkatan agen/alat: Peningkatan pasca-pelatihan memungkinkan panggilan alat yang lebih cerdas — model mengharapkan format JSON panggilan alat yang ketat untuk eksekusi alat yang aman dan deterministik.
Pertukaran kinerja: Mode berpikir menghabiskan token untuk penalaran berantai internal dan bisa lebih lambat/lebih intensif token; mode tanpa berpikir lebih cepat dan lebih murah. Tolok ukur dalam kartu model menunjukkan peningkatan substansial di seluruh tolok ukur penalaran dan kode untuk V3.1.
Bagaimana model tersebut disusun
Tulang punggung Kementerian Lingkungan Hidup: jumlah parameter total yang besar dengan subset aktif yang lebih kecil per token (inferensi ekonomis).
Pelatihan konteks panjang: V3.1 memperluas fase konteks panjang secara signifikan (32k → pelatihan yang lebih besar pada dokumen panjang) untuk mendukung jendela 128K+ dalam beberapa versi.
Alur kerja asli FP8: DeepSeek menggunakan format FP8 secara luas (w8a8 / UE8M0) untuk efisiensi bobot/aktivasi; skrip konversi komunitas ada jika Anda lebih suka BF16/FP16.
Apa saja persyaratan untuk menjalankan DeepSeek-V3.1 secara lokal? (Perangkat keras, penyimpanan, dan perangkat lunak)
Menjalankan penuh Model V3.1 (tanpa kuantisasi) merupakan proyek besar. Berikut adalah kategori pengaturan yang realistis dan apa yang biasanya dibutuhkan.
Ember Praktis
Cluster / penelitian-lab (model lengkap): beberapa GPU memori tinggi (kelas H100/H800 atau banyak GPU Ada/Hopper), multi-node dengan puluhan GPU, banyak penyimpanan NVMe (ratusan GB), dan kerangka kerja inferensi khusus (SGLang, vLLM, LMDeploy, TRT-LLM).
Server tunggal kelas atas (terkuantisasi):: dimungkinkan dengan kuantisasi berat (INT4/AWQ/AWQ2/gguf) dan kerangka kerja seperti Ollama (paket awal) atau GGUF komunitas — masih memerlukan ~puluhan hingga ratusan GB RAM GPU atau pembongkaran CPU+GPU yang cerdas.
Laptop pengembang / kotak dev: tidak dapat diterapkan pada model penuh; gunakan varian kecil yang disaring/disempurnakan atau hubungkan ke server lokal/instansi Ollama.
Daftar periksa perangkat keras (praktis)
GPUUntuk throughput inferensi nyata dari V3.1 lengkap: klaster multi-GPU (H100 / H800 / Ada Lovelace+). Untuk eksekusi FP8, diperlukan GPU dengan kemampuan komputasi dan dukungan driver.
RAM & penyimpananHarapkan ratusan GB ruang kosong untuk berkas model (halaman model mencantumkan beberapa ratus GB tergantung format/kuantisasi), ditambah ruang kerja untuk format yang dikonversi. Metadata Ollama mencantumkan jejak sekitar 400 GB untuk paket DeepSeek V3.1 Ollama di pustaka.
jaringan: Untuk inferensi multi-simpul, Anda memerlukan interkoneksi latensi rendah (NVLink / InfiniBand) dan perkakas orkestrasi untuk pengaturan tensor-paralel.
Daftar periksa perangkat lunak
OS: Linux direkomendasikan untuk alat inferensi komunitas (demo DeepSeek-Infer mencantumkan Linux/Python).
Ular sanca: 3.10+ (dalam banyak contoh DeepSeek). Versi paket tipikal disematkan di repositori requirements.txt.
Kerangka kerja & alat (pilih satu atau lebih): SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM, atau Ollama untuk instalasi lokal yang lebih sederhana. Masing-masing memiliki instruksi dan dukungan presisi/kuantisasi yang berbeda.
Catatan praktis: Jika Anda hanya memiliki satu GPU konsumen (misalnya, 24–48 GB), kemungkinan besar Anda akan menggunakan GGUF terkuantisasi atau inferensi jarak jauh; jika Anda memiliki stasiun kerja dengan RAM >128 GB ditambah kluster GPU kelas H100/H200, Anda dapat menargetkan inferensi FP8/FP16 fidelitas lebih tinggi dengan vLLM.
Bagaimana cara menjalankan DeepSeek-V3.1 secara lokal?
Berikut ini adalah beberapa jalur praktis yang dapat Anda gunakan, dari yang paling manual / fleksibel hingga jalur termudah untuk satu kotak pengembang. Saya akan memberikan tutorial langkah demi langkah dan contoh kode
Opsi A — Demo resmi DeepSeek-Infer (jalur pengembangan / klaster)
Ini adalah contoh/demo repositori untuk inferensi FP8/BF16. Gunakan jika Anda berencana menggunakan multi-node atau ingin bereksperimen dengan kode inferensi resmi.
(Repo inference/requirements.txt mencantumkan versi obor/triton/transformer yang disematkan dan direkomendasikan oleh tim.)
Unduh bobot model
Unduh dari halaman model Wajah Pelukan (deepseek-ai/DeepSeek-V3.1) dan letakkan di bawah /path/to/DeepSeek-V3Kartu model dan repo mencatat tautan penyimpanan resmi Hugging Face.
Konversi bobot untuk demo
# example conversion command shown in the repo
python convert.py --hf-ckpt-path /path/to/DeepSeek-V3 --save-path /path/to/DeepSeek-V3-Demo --n-experts 256 --model-parallel 16
Ini adalah contoh kanonik dari repo DeepSeek untuk menjalankan gaya klaster.
Opsi B — vLLM (disarankan untuk penerapan server & API yang kompatibel dengan OpenAI)
vLLM mendukung DeepSeek dalam mode FP8/BF16 dan menyediakan server yang kompatibel dengan OpenAI. Ini merupakan jalur produksi yang populer untuk model besar karena optimasi memori dan kompatibilitas API.
Mulai server vLLM yang akan mengambil model dari Hugging Face (pola contoh):
# this will download/serve the model (replace with exact model id if needed)
vllm serve deepseek-ai/DeepSeek-V3.1 --host 0.0.0.0 --port 8000
Kemudian minta pelengkapan dengan curl atau klien yang kompatibel dengan OpenAI:
curl -s -X POST "http://localhost:8000/v1/completions" \
-H "Content-Type: application/json" \
-d '{"model":"DeepSeek-V3.1","prompt":"Explain the QuickSort algorithm", "max_tokens":200}'
Resep dan dokumen vLLM mencakup contoh DeepSeek dan catatan tentang kompatibilitas FP8 dan paralelisme multi-GPU/pipeline. Untuk model yang lebih berat, Anda tetap memerlukan beberapa GPU atau varian terkuantisasi.
Repo DeepSeek secara eksplisit merekomendasikan SGLang, Penerapan LMD, dan TensorRT-LLM sebagai mesin yang dioptimalkan untuk DeepSeek V3. Mesin ini menyediakan latensi inferensi, throughput, dan kernel FP8 yang lebih baik.
Pemanggilan LMDeploy yang umum (lihat dokumen LMDeploy untuk CLI yang tepat):
# pseudo-example; refer to LMDeploy docs for exact options
lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080
Tolok ukur dan resep peluncuran SGLang tersedia di repo dan di proyek SGLang benchmark/deepseek_v3 folder. Gunakan tumpukan ini saat Anda mengontrol kluster GPU dan menginginkan throughput produksi.
Opsi D — Ollama (rute pengembangan lokal termudah, seringkali satu mesin)
Jika Anda menginginkan cara paling mudah untuk menjalankan DeepSeek secara lokal (dan Anda dapat menghemat disk), Ollama menyediakan model paket dan CLI sederhana (ollama pull, ollama run). DeepSeek-V3.1 muncul di pustaka Ollama dan dapat dijalankan secara lokal (Ollama mungkin memerlukan versi terbaru/pra-rilis untuk beberapa fitur).
Contoh (Ollama CLI):
# Pull the model (downloads the model artifacts to your disk)
ollama pull deepseek-v3.1
# Start an interactive session:
ollama run deepseek-v3.1
# Or run as a local API server (Ollama supports a local API)
# Example: POSTing to Ollama's local API (adjust host/port to your setup)
curl -X POST http://localhost:11434/api/generate \
-H 'Content-Type: application/json' \
-d '{"model":"deepseek-v3.1","prompt":"Summarize the following paper: ..."}'
Ollama mengabstraksi banyak detail distribusi/kuantisasi dan dapat menjadi cara yang ampuh untuk menguji perilaku model pada satu host. Catatan: halaman model mencantumkan ukuran paket sekitar 404GB untuk entri Ollama, jadi rencanakan disk & RAM yang sesuai.
Apa itu Mode Berpikir dan bagaimana cara menggunakannya
DeepSeek-V3.1 mengimplementasikan token pemikiran hibrida pendekatan: titik pemeriksaan yang sama dapat berjalan di pikir mode (token “rantai pemikiran” internal) atau tidak berpikir mode dengan mengganti templat obrolan/prompt. Model ini menggunakan token eksplisit seperti <think> (dan penutupan </think> (dalam beberapa templat) untuk menandakan rantai pemikiran internal versus pembangkitan jawaban langsung. Kartu model mendokumentasikan awalan berpikir dan tidak berpikir serta menunjukkan perbedaan templat.
Contoh: membuat pesan dalam Python (tokenizer helper)
Kartu model Wajah Pelukan berisi cuplikan praktis yang menunjukkan cara menerapkan templat obrolan melalui tokenizer. Ini adalah pola yang direkomendasikan untuk menghasilkan pikir or tidak berpikir perintah yang diformat:
Beralih thinking=True untuk menghasilkan prompt yang menggunakan <think> awalan; thinking=False menghasilkan templat non-berpikir. Model akan berperilaku berbeda (musyawarah internal vs. respons langsung) bergantung pada bendera ini.
Referensi cepat — pemecahan masalah kecil & praktik terbaik
Jika Anda kehabisan memori GPU: Cobalah build terkuantisasi (AWQ/q4/INT4) atau GGUF komunitas; banyak ruang komunitas menerbitkan kuantisasi untuk penggunaan lokal. Ollama/vLLM juga dapat menyediakan build terkuantisasi yang lebih kecil.
Jika Anda memerlukan model untuk memanggil alat eksternal: Mengadopsi Panggilan Alat Skema di templat obrolan sama persis. Uji format JSON alat secara luring dan periksa apakah kode orkestrasi Anda (bagian yang menjalankan alat) mengembalikan JSON yang telah disucihamakan dan diketik kembali ke model.
Jika Anda membutuhkan konteks yang panjang: Gunakan vLLM atau SGLang dengan plugin konteks panjang; DeepSeek telah dilatih/diperluas secara eksplisit untuk konteks 32K/128K dan perangkat terkait mendukung jendela tersebut. Harapkan adanya kompromi memori.
Bisakah saya menjalankan DeepSeek-V3.1 di laptop atau server kecil?
Jawaban singkat: Ya, tetapi dengan peringatan. Kuantisasi komunitas (AWQ/GGUF/dinamika 1-bit) mengurangi jejak penyimpanan dan memori secara drastis dan memungkinkan para penghobi untuk menjalankan varian V3.1 pada desktop kelas atas (klaim memiliki ~170 GB working set). Namun:
Kesetiaan vs pertukaran ukuran: Kuantisasi agresif mengurangi memori tetapi dapat memengaruhi kinerja penalaran/kode. Uji pada beban kerja Anda.
Hukum & perizinan: Model ini memiliki lisensi MIT sesuai kartu model, tetapi kuantisasi pihak ketiga mungkin memiliki lisensi mereka sendiri; tinjau lisensi tersebut sebelum penggunaan produksi.
Penutup
DeepSeek-V3.1 merupakan langkah signifikan menuju model "agen" hibrida dengan perilaku berpikir/tidak berpikir yang eksplisit dan penggunaan alat yang lebih baik. Jika Anda ingin menjalankannya secara lokal, pilih jalur yang sesuai dengan perangkat keras dan toleransi risiko Anda:
Untuk penelitian:transformers + safetensor terkuantisasi dan mempercepat.
Untuk produksi & throughput: vLLM + multi-GPU (H100/H200).
Untuk eksperimen lokal: Ollama/llama.cpp + GGUF komunitas (gabungkan + jalankan).
Mulai
CometAPI adalah platform API terpadu yang menggabungkan lebih dari 500 model AI dari penyedia terkemuka—seperti seri GPT OpenAI, Gemini Google, Claude Anthropic, Midjourney, Suno, dan lainnya—menjadi satu antarmuka yang ramah bagi pengembang. Dengan menawarkan autentikasi yang konsisten, pemformatan permintaan, dan penanganan respons, CometAPI secara drastis menyederhanakan integrasi kapabilitas AI ke dalam aplikasi Anda. Baik Anda sedang membangun chatbot, generator gambar, komposer musik, atau alur kerja analitik berbasis data, CometAPI memungkinkan Anda melakukan iterasi lebih cepat, mengendalikan biaya, dan tetap tidak bergantung pada vendor—semuanya sambil memanfaatkan terobosan terbaru di seluruh ekosistem AI.
Pengembang dapat mengakses Pencarian Dalam-V3.1 melalui CometAPI, versi model terbaru yang tercantum adalah versi per tanggal publikasi artikel. Untuk memulai, jelajahi kemampuan model di tempat bermain dan konsultasikan Panduan API untuk petunjuk terperinci. Sebelum mengakses, pastikan Anda telah masuk ke CometAPI dan memperoleh kunci API. API Komet menawarkan harga yang jauh lebih rendah dari harga resmi untuk membantu Anda berintegrasi.
