Cara menyebarkan deepseek-v3.1 secara lokal melalui ollama: Panduan Timur

DeepSeek-V3.1 adalah model bahasa MoE hibrida "berpikir/tidak berpikir" (total 671 miliar, ≈37 miliar diaktifkan per token) yang dapat dijalankan secara lokal jika Anda menggunakan penyedia/kuantisasi dan perkakas yang tepat. Di bawah ini saya menjelaskan apa itu DeepSeek-V3.1, persyaratan perangkat keras/perangkat lunak, tutorial menjalankan lokal langkah demi langkah (contoh Ollama + llama.cpp), dan cara melakukannya. menyebarkan dan menggunakan Mode Berpikir (The <think>/</think> templat obrolan) dengan contoh kode yang dapat Anda salin/tempel.

Apa itu DeepSeek-V3.1?

DeepSeek-V3.1 adalah rilis v3.1 dari keluarga MoE (Mixture-of-Experts) DeepSeek. Model ini dirancang sebagai model inferensi hibrida yang mendukung dua templat/mode percakapan — Pikir dan Tidak Berpikir — dari titik pemeriksaan yang sama dengan mengubah templat obrolan. Arsitektur model ini menelusuri desain MoE DeepSeek-V3 (total 671 miliar parameter; ≈37 miliar parameter diaktifkan per token untuk inferensi) dan menambahkan penyempurnaan pasca-pelatihan untuk penggunaan alat, keterampilan agen, dan penanganan konteks panjang.

Sorotan fitur cepat

Hibrida Berpikir / Tidak Berpikir mode (diubah berdasarkan tokenisasi templat obrolan).
Arsitektur MoE: jumlah parameter total besar tetapi parameter aktif per token terbatas (memungkinkan efisiensi).
Peningkatan pasca-pelatihan untuk panggilan alat dan alur kerja agen (format panggilan alat dan templat agen didokumentasikan dalam aset model).

Apa yang saya perlukan untuk menjalankan DeepSeek-V3.1 secara lokal?

Menjalankan penuh DeepSeek-V3.1 (checkpoint mentah) sangat penting — penyimpanan pelatihan/checkpoint dan orkestrasi inferensi tidaklah mudah. Namun, ada beberapa cara praktis:

Perangkat keras

Inferensi terdistribusi penuh (penelitian/kluster): beberapa GPU bermemori tinggi (kelas A100/H800) atau kluster GPU dengan layanan paralel model (umum untuk checkpoint 600MB+). Gunakan hanya jika Anda menjalankan kluster riset produksi.
Pilihan lokal yang praktis: menggunakan parameter yang diaktifkan perspektif (≈37B diaktifkan) atau build dinamis GGUF/1-bit terkuantisasi. Kuantisasi komunitas (dinamis 1-bit / GGUF) mengurangi kebutuhan disk+RAM secara signifikan — misalnya, postingan komunitas melaporkan kompresi checkpoint 720GB menjadi ~170GB GGUF untuk varian terkuantisasi. Hal ini membuat inferensi GPU server tunggal lokal layak untuk desktop/server dengan sumber daya yang memadai.

Intinya: harapkan alur kerja model besar (puluhan hingga ratusan GB disk untuk artefak terkuantisasi); untuk GPU VRAM, gunakan varian terkuantisasi dan target ≥24–48 GB VRAM untuk throughput yang wajar; jika tidak, gunakan CPU+swap dengan pengorbanan kinerja.

Perangkat lunak & perkakas

Python 3.10+ (untuk perkakas transformer/tokenizer dan skrip kustom).

transformers (untuk fungsi tokenizer & helper) — kartu model menunjukkan contoh penggunaan transformers.AutoTokenizer.

Satu atau lebih runtime inferensi lokal:

Ollama (mudah: ollama pull / ollama run Integrasi; beberapa build DeepSeek di Ollama memerlukan versi pra-rilis, periksa catatan model/ollama). Ollama telah menjadi pelari lokal standar untuk model komunitas.
llama.cpp / ggml tumpukan atau llama-server untuk file terkuantisasi GGUF — bagus untuk eksekusi GGUF langsung.
inferensi-pembuatan-teks / Triton / tumpukan FlashAttention untuk inferensi GPU berkinerja lebih tinggi (pengaturan lanjutan).

Disk: ruang kosong besar untuk file model (puluhan → ratusan GB tergantung pada kuantisasi).

Artefak model (file mana yang akan didapatkan)

Varian safetensor resmi / BF16 / FP8 / GGUF: Hugging Face menampung artefak model V3.1 dan beberapa kuantisasi. Jika Anda memerlukan file GGUF/terkuantisasi untuk llama.cpp, cari rilis kuantisasi komunitas (atau skrip konversi dari safetensors → GGUF) — kartu model mencantumkan varian terkuantisasi.

Bagaimana cara menyiapkan model untuk inferensi lokal?

Berikut adalah langkah-langkah persiapan yang disarankan yang disusun dari sederhana → lanjutan.

Langkah 1 — Pilih waktu proses (rekomendasi)

Tes pemula / cepat: Ollama — pengaturan minimal: unduh, jalankan model, panggil API. Catatan: beberapa versi DeepSeek-V3.1 mencatat Ollama v0.11.7 sebagai persyaratan untuk fitur tertentu.
Kontrol tingkat lanjut/rendah: llama.cpp + Kuantitas GGUF (jika kuantisasi GGUF tersedia). Ini memberi Anda kendali inferensi langsung dan integrasi dengan llama-server.

Langkah 2 — Unduh modelnya

Jika Anda menggunakan Ollama:

# install ollama (see https://ollama.com/docs)

# Pull the model (this downloads the model to your machine)
ollama pull deepseek-ai/DeepSeek-V3.1
# or a specific tag: ollama pull deepseek-ai/DeepSeek-V3.1:quant-q4_0

(Ollama's run akan menarik secara otomatis jika tidak ada; pull memungkinkan Anda mengontrol waktu.)

Jika Anda menggunakan Hugging Face + llama.cpp:

# Example: download via huggingface-cli or hf_transfer

pip install huggingface_hub
hf_hub_download(repo_id="deepseek-ai/DeepSeek-V3.1", filename="DeepSeek-V3.1.gguf")
# or use a community quant file (gguf) referenced on the Hugging Face model page

Hugging Face mencantumkan artefak model, templat, dan kuantisasi pada kartu model.

Langkah 3 — Konversi / kuantisasi (opsional)

Jika Anda hanya menemukan safetensor atau artefak BF16 tetapi membutuhkan GGUF untuk llama.cpp, gunakan skrip konversi di llama.cpp (atau alat komunitas) untuk mengonversi → mengkuantisasi. Ada alat komunitas untuk kuantisasi dinamis 1-bit yang mempertahankan akurasi sekaligus mengecilkan ukuran; lihat postingan komunitas yang melaporkan penurunan hingga ~170GB.

Bagaimana cara menjalankan DeepSeek-V3.1 secara lokal? (Tutorial praktis)

Aku akan menunjukkannya Ollama (mudah, direkomendasikan) dan panggilan.cpp (GGUF) ditambah contoh Python singkat yang menggunakan pembantu tokenizer model-card.

A — Berlari bersama Ollama (mulai cepat)

Instal Ollama (ikuti petunjuk resmi).
Tarik dan jalankan model:

# pull model to disk (optional; run will pull automatically)

ollama pull deepseek-ai/DeepSeek-V3.1

# start an interactive session (runs model and exposes local API)

ollama run deepseek-ai/DeepSeek-V3.1

Buat permintaan HTTP ke server Ollama lokal:

# curl usage example (local Ollama server usually listens on port 11434)

curl -sS -X POST 'http://localhost:11434/api/generate' \
  -H 'Content-Type: application/json' \
  -d '{
    "model":"deepseek-ai/DeepSeek-V3.1",
    "prompt":"Explain the difference between thinking and non-thinking mode in DeepSeek.",
    "max_tokens":256
  }'

Pola CLI dan API Ollama dirancang agar sederhana: ollama run Akan menarik jika diperlukan dan meluncurkan server model. Lihat dokumen Ollama dan halaman model untuk petunjuk memori dan nama/tag model yang tepat.

B — Menjalankan GGUF terkuantisasi melalui llama.cpp

Membangun llama.cpp dengan CUDA (opsional) atau CPU:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
# for CUDA:

make clean && make LLAMA_CUBLAS=1
# or CPU only:

make

Tempatkan file model GGUF di suatu jalur dan jalankan:

./main -m /path/to/DeepSeek-V3.1.q4_K_M.gguf \
  -p "Explain how to enable thinking mode." \
  --temp 0.2 --n_predict 512

Untuk penggunaan server, llama-server (proyek komunitas) dapat mengekspos titik akhir HTTP:

llama-server -m /path/to/DeepSeek-V3.1.q4_K_M.gguf
# then POST to the server like:

curl -X POST "http://localhost:8080/api/v1/generate" -d '{"prompt":"Hello","max_tokens":200}'

Gunakan kuantisasi GGUF komunitas (q4/q8/1-bit dinamis) agar sesuai dengan anggaran GPU/CPU; llama.cpp repo menyediakan alat konversi dan panduan.

Contoh C — Python menggunakan tokenizer + template obrolan

Kartu model Wajah Pelukan menyediakan tokenizer.apply_chat_template pembantu dan menunjukkan cara mengkodekan percakapan dengan thinking=TrueBerikut contoh Python minimal yang diadaptasi dari kartu model:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")

messages = [
    {"role": "system", "content": "You are a helpful assistant"},
    {"role": "user", "content": "Who are you?"},
    {"role": "assistant", "content": "<think>Hmm</think>I am DeepSeek"},
    {"role": "user", "content": "1+1=?"}
]

# apply thinking chat template

s = tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)
print(s)  # the template includes the special <think> token placement

Anda kemudian dapat memasukkan perintah tokenisasi ke dalam runtime inferensi Anda (Ollama/llama.cpp/TGI) tergantung pada tumpukan Anda.

Bagaimana cara kerja Thinking Mode dan bagaimana cara menerapkannya secara lokal?

DeepSeek-V3.1 menggunakan templat obrolan yang berisi token pemikiran khusus (misalnya, <think> dan </think>). Itu Template menentukan apakah model berada dalam mode Berpikir atau Tidak Berpikir:

Tidak Berpikir tempat templat </think> dalam awalan asisten, yang menginstruksikan model untuk menghasilkan respons langsung (format pemanggilan alat didukung dalam non-pemikiran).
Pikir tempat templat <think> pada awalan asisten yang membuat model mengeluarkan sinyal perantara gaya rantai pemikiran internal (model dilatih untuk menggunakan urutan token tersebut untuk bernalar secara internal dan menghasilkan jawaban multi-langkah berkualitas lebih tinggi). Kartu model Hugging Face mendokumentasikan token-token yang tepat ini dan tokenizer.apply_chat_template(..., thinking=True) API.

Pengalih terprogram (contoh)

A — Dengan tokenizer (Python):

# thinking=True or thinking=False changes how the prompt is formatted

prompt_thinking = tokenizer.apply_chat_template(messages, thinking=True, add_generation_prompt=True)
prompt_non_thinking = tokenizer.apply_chat_template(messages, thinking=False, add_generation_prompt=True)

Umpan prompt_thinking ke runtime inferensi Anda untuk mendapatkan perilaku Berpikir.

B — Dengan prompt mentah (llama.cpp / manual):

Menyisipkan <think> sebelum asisten berbalik saat Anda meminta:

<｜begin_of_sentence｜>You are a helpful assistant<｜User｜>How to optimize this code?<｜Assistant｜><think>

(Bingkai token yang persis itu ada di kartu model — Anda harus menghormati spasi dan penanda khusus jika Anda menggunakan templat mentah.)

C — Dengan Ollama (pengalih UI):
Demo web resmi DeepSeek dan catatan rilis menyebutkan tombol "DeepThink" untuk beralih mode di UI yang dihosting. Secara lokal, Ollama atau aplikasi Anda harus mereplikasi perilaku tersebut dengan mengganti templat obrolan (yaitu, mengubah prompt yang Anda kirim ke runtime di antara dua formulir yang ditokenisasi). Jika Anda menjalankan DeepSeek melalui Ollama, Anda dapat mengimplementasikannya di aplikasi Anda dengan mempertahankan dua templat prompt (berpikir vs. tidak berpikir) dan melakukan pengalihan yang Anda teruskan melalui API Ollama.

Bagaimana cara menyebarkan Thinking Mode sebagai agen (panggilan alat, agen kode)?

Dokumen DeepSeek-V3.1 panggilan alat dan agen templat dalam aset model. Model ini mengharapkan alat disajikan dalam format JSON/instruksi tertentu dan mendukung penggabungan beberapa panggilan alat dalam satu putaran jika Anda mengikuti token pembungkus yang dijelaskan dalam kartu model.

Contoh: pembungkus pemanggilan alat sederhana (pseudo)

Model ini menentukan blok deskriptor alat dan batasan ketat tool_calls_begin / tool_call_begin format. Contoh minimal (konseptual):

## Tools

You have access to the following tools:

### web_search

Description: Query the web
Parameters: {"q": "string"}

<｜begin_of_sentence｜>{system prompt}

## Tools

...tool descriptions...

<｜User｜>Find the population of Tokyo<｜Assistant｜></think>
<｜tool_calls_begin｜><｜tool_call_begin｜>web_search<｜tool_sep｜>{"q":"population of Tokyo 2025"}<｜tool_call_end｜><｜tool_calls_end｜>

Output alat kemudian harus diumpankan kembali ke model pada putaran berikutnya mengikuti format yang ditentukan model (lihat assets/search_tool_trajectory.html (Lihat di halaman model untuk alur yang tepat). Implementasi agen memerlukan orkestrasi terprogram: panggil alat → tangkap hasil → masukkan kembali hasil ke dalam konteks obrolan persis seperti yang ditentukan templat → panggil model lagi.

Tips praktis, pemecahan masalah, dan catatan keselamatan (Apa yang harus saya perhatikan?)

Templat token bersifat ketat. Gunakan modelnya tokenizer.apply_chat_template atau mereproduksi persisnya <think>/</think> token seperti yang ditunjukkan. Spasi yang salah atau penanda yang hilang akan mengubah perilaku model.
Format alat harus berupa JSON yang valid. Model akan mengurai argumen alat sebagai JSON — JSON yang tidak valid akan merusak panggilan alat.
Pertukaran kuantisasi. Kuantisasi dinamis/agresif 1-bit akan mengurangi penyimpanan dan RAM, tetapi mungkin sedikit mengubah fidelitas numerik. Uji pada beban kerja Anda. Kuantisasi komunitas yang mengurangi 80% penggunaan disk memang ada (contoh laporan: 720GB → ~170GB), tetapi selalu validasi dengan perintah Anda.
Kompatibilitas Ollama. Beberapa varian DeepSeek mencatat Ollama v0.11.7 sebagai yang dipersyaratkan untuk fitur pra-rilis — periksa halaman model Ollama dan perbarui sebagaimana mestinya.

Contoh ujung ke ujung: menjalankan DeepSeek-V3.1 secara lokal dengan Thinking Mode (panduan mini)

Instal Ollama dan tarik modelnya:

# install ollama per docs, then:

ollama pull deepseek-ai/DeepSeek-V3.1
ollama run deepseek-ai/DeepSeek-V3.1 &

Gunakan tokenizer Python untuk menyusun perintah berpikir:

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")

msgs = [
  {"role":"system","content":"You are a helpful assistant."},
  {"role":"user","content":"Plan a multi-step strategy to prototype a mobile app in 2 weeks."}
]
prompt = tokenizer.apply_chat_template(msgs, thinking=True, add_generation_prompt=True)

import requests
resp = requests.post("http://localhost:11434/api/generate", json={
    "model": "deepseek-ai/DeepSeek-V3.1",
    "prompt": prompt,
    "max_tokens": 400
})
print(resp.json())

Jika model mengembalikan panggilan alat dalam format toolcall, parsing JSON dan jalankan alat, lalu masukkan hasil ke pesan berikutnya sesuai templat kartu model.

Bagaimana Anda harus memilih jalur penempatan Anda?

Jika Anda menginginkan jalur tercepat untuk bereksperimen: menggunakan Ollama dan contoh kartu model Hugging Face. Ollama menyembunyikan banyak detail infrastruktur dan menyediakan API HTTP lokal.
Jika Anda memerlukan biaya lebih rendah/portabilitas lebih tinggi: menggunakan komunitas GGUF terkuantisasi artefak dan dijalankan dengan llama.cpp or llama-serverKuantisasi menghemat disk dan memori tetapi menguji akurasi untuk beban kerja Anda.
Jika Anda membangun agen atau alat: ikuti kartu modelnya panggilan alat dan agen templat secara tepat; mengatur kembali keluaran alat ke dalam konteks model.

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.

Kesimpulan

DeepSeek-V3.1 menghadirkan filosofi inferensi hibrida praktis (satu titik pemeriksaan + perilaku berpikir templat) yang memudahkan eksperimen dengan penalaran gaya rantai pemikiran dan penggunaan alat agen jika Anda mematuhi templat obrolan dan persyaratan alat. Gunakan kartu model Hugging Face dan catatan rilis DeepSeek sebagai langkah awal Anda, pilih runtime lokal (Ollama untuk penyederhanaan, llama.cpp untuk kontrol), dan menguji build terkuantisasi untuk penerapan lokal praktis.