Cara menggunakan deepseek-v3.1 secara tempatan melalui ollama: The Eastest Guide

DeepSeek-V3.1 ialah model bahasa MoE "berfikir / tidak berfikir" hibrid (jumlah 671B, ≈37B diaktifkan setiap token) yang boleh dijalankan secara setempat jika anda menggunakan pembekal/kuantisasi dan perkakas yang betul. Di bawah saya menerangkan apa itu DeepSeek-V3.1, keperluan perkakasan/perisian, tutorial larian tempatan langkah demi langkah (contoh Ollama + llama.cpp), dan cara untuk gunakan dan gunakan Mod Berfikir (Yang <think>/</think> templat sembang) dengan contoh kod yang anda boleh salin/tampal.

Apakah DeepSeek-V3.1?

DeepSeek-V3.1 ialah keluaran v3.1 bagi keluarga DeepSeek MoE (Mixture-of-Experts). Ia direka bentuk sebagai model inferens hibrid yang menyokong dua templat/mod perbualan — Berfikir and Tidak Berfikir — dari pusat pemeriksaan yang sama dengan menukar templat sembang. Seni bina model menjejak kepada reka bentuk DeepSeek-V3 MoE (jumlah parameter 671B; ≈37B parameter diaktifkan setiap token untuk inferens) dan menambah penambahbaikan selepas latihan untuk penggunaan alat, kemahiran ejen dan pengendalian konteks panjang.

Sorotan ciri pantas

hibrid Berfikir / Tidak Berfikir mod (ditogol oleh tokenisasi templat sembang).
Seni bina MoE: jumlah kiraan parameter yang besar tetapi param diaktifkan terhad bagi setiap token (membolehkan kecekapan).
Rangsangan selepas latihan untuk panggilan alat dan aliran kerja ejen (format panggilan alat dan templat ejen yang didokumenkan dalam aset model).

Apakah yang saya perlukan untuk menjalankan DeepSeek-V3.1 secara tempatan?

Running the penuh DeepSeek-V3.1 (pusat pemeriksaan mentah) adalah kelas berat — penyimpanan latihan/pusat pemeriksaan dan orkestrasi inferens adalah tidak penting. Tetapi terdapat laluan praktikal:

perkakasan

Inferens teragih penuh (penyelidikan / kelompok): berbilang GPU memori tinggi (kelas A100/H800) atau gugusan GPU dengan servis selari model (biasa untuk pusat pemeriksaan 600B+). Gunakan hanya jika anda menjalankan kluster penyelidikan pengeluaran.
Pilihan tempatan yang praktikal: menggunakan diaktifkan-param perspektif (≈37B diaktifkan) atau binaan dinamik GGUF/1-bit terkuantisasi. Pengkuantitian komuniti (dinamik 1-bit / GGUF) mengurangkan keperluan cakera+RAM dengan ketara — cth, siaran komuniti melaporkan memampatkan pusat pemeriksaan 720GB kepada ~170GB GGUF untuk varian terkuantiti. Itu menjadikan inferens GPU pelayan tunggal tempatan boleh dilaksanakan untuk desktop/pelayan yang mempunyai sumber yang baik.

Pokoknya: mengharapkan aliran kerja model besar (berpuluh hingga ratusan GB cakera untuk artifak terkuantiti); untuk GPU VRAM, gunakan varian terkuantisasi dan sasaran ≥24–48GB VRAM untuk daya pemprosesan yang munasabah; sebaliknya gunakan CPU+swap dengan pertukaran prestasi.

Perisian & perkakas

Python 3.10+ (untuk alat pengubah/tokenizer dan skrip tersuai).

transformers (untuk fungsi tokenizer & pembantu) — kad model menunjukkan contoh menggunakan transformers.AutoTokenizer.

Satu atau lebih masa jalan inferens setempat:

Ollama (mudah: ollama pull / ollama run integrasi; sesetengah DeepSeek binaan pada Ollama memerlukan versi prakeluaran, semak model/nota ollama). Ollama telah menjadi pelari tempatan standard untuk model komuniti.
llama.cpp / ggml timbunan atau llama-server untuk fail terkuantiti GGUF — bagus untuk pelaksanaan GGUF langsung.
teks-generasi-inferens / Triton / FlashAttention tindanan untuk inferens GPU berprestasi lebih tinggi (persediaan lanjutan).

Cakera: ruang kosong yang besar untuk fail model (puluhan → ratusan GB bergantung pada kuantiti).

Artifak model (fail mana yang hendak diperolehi)

Peti keselamatan rasmi / BF16 / FP8 / varian GGUF: Memeluk Wajah hos artifak model V3.1 dan berbilang kuantisasi. Jika anda memerlukan fail GGUF/kuantisasi untuk llama.cpp, cari keluaran pengkuantitian komuniti (atau skrip penukaran daripada safetensors → GGUF) — kad model menyenaraikan varian terkuantisasi.

Bagaimanakah saya menyediakan model untuk inferens setempat?

Di bawah adalah langkah penyediaan yang disyorkan disusun daripada mudah → lanjutan.

Langkah 1 — Pilih masa jalan (pengesyoran)

Ujian pemula / pantas: Ollama — persediaan minimum: muat turun, jalankan model, panggil API. Nota: sesetengah DeepSeek-V3.1 membina nota Ollama v0.11.7 seperti yang diperlukan untuk ciri khusus.
Kawalan lanjutan / peringkat rendah: llama.cpp + Kuantiti GGUF (jika kuantisasi GGUF tersedia). Ini memberi anda kawalan inferens langsung dan penyepaduan dengan llama-server.

Langkah 2 — Muat turun model

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 automatik jika tidak hadir; pull membolehkan anda mengawal masa.)

Jika anda menggunakan Memeluk Muka + 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

Wajah Memeluk menyenaraikan artifak model, templat dan kuantisasi pada kad model.

Langkah 3 — Tukar / kuantiti (pilihan)

Jika anda hanya menemui safetensors atau artifak BF16 tetapi memerlukan GGUF untuk llama.cpp, gunakan skrip penukaran dalam llama.cpp (atau alatan komuniti) untuk menukar → kuantiti. Terdapat alat komuniti untuk pengkuantitian dinamik 1-bit yang mengekalkan ketepatan sambil mengecilkan saiz; lihat siaran komuniti yang melaporkan kepada ~170GB.

Bagaimanakah saya boleh menjalankan DeepSeek-V3.1 secara tempatan? (Tutorial larian praktikal)

Saya akan tunjukkan Ollama (mudah, disyorkan) dan call.cpp (GGUF) serta contoh Python pendek menggunakan pembantu tokenizer kad model.

A — Berlari dengan Ollama (permulaan pantas)

Pasang Ollama (ikut arahan rasmi).
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 kepada pelayan Ollama tempatan:

# 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
  }'

Corak CLI dan API Ollama direka untuk menjadi mudah: ollama run akan menarik jika perlu dan melancarkan pelayan model. Lihat dokumen Ollama dan halaman model untuk petunjuk memori dan nama/teg model yang tepat.

B — Menjalankan GGUF terkuantisasi melalui llama.cpp

Membina llama.cpp dengan CUDA (pilihan) 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

Letakkan fail model GGUF dalam laluan 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 kegunaan pelayan, llama-server (projek komuniti) boleh mendedahkan 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 pengkuantitian GGUF komuniti (dinamik q4/q8/1-bit) untuk dimuatkan ke dalam belanjawan GPU/CPU; yang llama.cpp repo menyediakan alat dan panduan penukaran.

C — Contoh Python menggunakan templat tokenizer + sembang

Kad model Berpeluk Wajah menyediakan a tokenizer.apply_chat_template pembantu dan menunjukkan cara mengekod perbualan dengan thinking=True. Berikut ialah contoh Python minimum yang disesuaikan daripada kad 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 kemudiannya boleh menyuap gesaan token ke dalam masa jalan inferens anda (Ollama/llama.cpp/TGI) bergantung pada tindanan anda.

Bagaimanakah Mod Berfikir berfungsi dan bagaimana cara saya menggunakan mod itu secara tempatan?

DeepSeek-V3.1 menggunakan templat sembang yang mengandungi token pemikiran khas (cth, <think> and </think>). The template menentukan sama ada model dalam mod Berfikir atau Tidak Berfikir:

Tidak Berfikir tempat templat </think> dalam awalan pembantu, yang mengarahkan model untuk menghasilkan respons langsung (format alat panggilan disokong dalam bukan berfikir).
Berfikir tempat templat <think> dalam awalan pembantu yang menjadikan model mengeluarkan isyarat perantaraan gaya rantaian pemikiran dalaman (model dilatih untuk menggunakan jujukan token itu untuk menaakul secara dalaman dan menghasilkan jawapan berbilang langkah yang berkualiti tinggi). Kad model Hugging Face mendokumenkan token yang tepat ini dan tokenizer.apply_chat_template(..., thinking=True) API.

Togol pengaturcaraan (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)

Memberi makan prompt_thinking kepada masa jalan inferens anda untuk mendapatkan tingkah laku Berfikir.

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

Memasukkan <think> sebelum pembantu bertukar apabila anda menggesa:

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

(Bingkai token tepat itu terdapat dalam kad model — anda mesti menghormati jarak dan penanda khas jika anda menggunakan templat mentah.)

C — Dengan Ollama (togol UI):
Demo web DeepSeek rasmi dan nota keluaran menyebut togol/butang "DeepThink" untuk menukar mod dalam UI yang dihoskan. Secara tempatan, Ollama atau apl anda harus meniru gelagat itu dengan menukar templat sembang (iaitu, menukar gesaan yang anda hantar kepada masa jalan antara dua borang token). Jika anda menjalankan DeepSeek melalui Ollama, anda boleh melaksanakan ini dalam aplikasi anda dengan mengekalkan dua templat segera (berfikir vs tidak berfikir) dan menogol yang anda lalui melalui API Ollama.

Bagaimanakah cara saya menggunakan Mod Berfikir sebagai ejen (panggilan alat, ejen kod)?

Dokumen DeepSeek-V3.1 panggilan alat and ejen templat dalam aset model. Model ini menjangkakan alatan akan dibentangkan dalam format JSON/arahan tertentu dan menyokong merantai beberapa panggilan alat dalam satu pusingan jika anda mengikut token pembalut tepat yang diterangkan dalam kad model.

Contoh: pembungkus panggilan alat mudah (pseudo)

Model menentukan blok deskriptor alat dan ketat tool_calls_begin / tool_call_begin format. Contoh minimum (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 kemudiannya hendaklah disalurkan semula kepada model pada giliran seterusnya mengikut format yang ditetapkan model (lihat assets/search_tool_trajectory.html pada halaman model untuk aliran yang tepat). Ejen pelaksana memerlukan orkestrasi terprogram: alat panggilan → hasil tangkapan → masukkan hasil kembali ke dalam konteks sembang tepat seperti yang ditetapkan templat → model panggilan semula.

Petua praktikal, penyelesaian masalah dan nota keselamatan (Apakah yang perlu saya perhatikan?)

Templat token adalah ketat. Gunakan model tokenizer.apply_chat_template atau menghasilkan semula dengan tepat <think>/</think> token seperti yang ditunjukkan. Jarak yang salah atau penanda yang hilang akan mengubah tingkah laku model.
Format alat mestilah JSON yang sah. Model akan menghuraikan argumen alat sebagai JSON — JSON yang tidak sah akan memutuskan panggilan alat.
Pengiraan kuantisasi. Pengkuantitian dinamik / agresif 1-bit mengecilkan storan dan RAM tetapi mungkin mengubah sedikit kesetiaan berangka. Uji beban kerja anda. Kuantiti komuniti yang menurunkan 80% penggunaan cakera wujud (contoh laporan: 720GB → ~170GB), tetapi sentiasa mengesahkan dengan gesaan anda.
Keserasian Ollama. Beberapa varian DeepSeek mencatatkan Ollama v0.11.7 seperti yang diperlukan untuk ciri prakeluaran — semak halaman model Ollama dan kemas kini dengan sewajarnya.

Contoh hujung ke hujung: jalankan DeepSeek-V3.1 secara setempat dengan Mod Berfikir (panduan mini)

Pasang Ollama dan tarik model:

# install ollama per docs, then:

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

Gunakan tokenizer Python untuk mengarang gesaan pemikiran:

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 panggilan alat, huraikan JSON dan jalankan alat, kemudian masukkan hasil ke dalam mesej seterusnya mengikut templat kad model.

Bagaimanakah anda harus memilih laluan penggunaan anda?

Jika anda mahukan laluan terpantas untuk bereksperimen: penggunaan Ollama dan contoh kad model Memeluk Wajah. Ollama menyembunyikan banyak butiran infra dan memberikan API HTTP setempat.
Jika anda memerlukan kos yang lebih rendah / lebih mudah alih: menggunakan komuniti GGUF dikuantisasi artifak dan dijalankan dengan llama.cpp or llama-server. Kuantiti menjimatkan cakera dan memori tetapi menguji ketepatan untuk beban kerja anda.
Jika anda membina ejen atau alatan: ikut kad model panggilan alat and ejen templat tepat; mengatur keluaran alat kembali ke dalam konteks model.

Bermula

CometAPI ialah platform API bersatu yang mengagregatkan lebih 500 model AI daripada pembekal terkemuka—seperti siri GPT OpenAI, Google Gemini, Anthropic's Claude, Midjourney, Suno dan banyak lagi—menjadi satu antara muka mesra pembangun. Dengan menawarkan pengesahan yang konsisten, pemformatan permintaan dan pengendalian respons, CometAPI secara dramatik memudahkan penyepaduan keupayaan AI ke dalam aplikasi anda. Sama ada anda sedang membina chatbots, penjana imej, komposer muzik atau saluran paip analitik terdorong data, CometAPI membolehkan anda mengulangi dengan lebih pantas, mengawal kos dan kekal sebagai vendor-agnostik—semuanya sambil memanfaatkan penemuan terkini merentas ekosistem AI.

Pembangun boleh mengakses DeepSeek V3.1 melalui CometAPI, versi model terkini yang disenaraikan adalah pada tarikh penerbitan artikel. Untuk memulakan, terokai keupayaan model dalam Taman Permainan dan berunding dengan Panduan API untuk arahan terperinci. Sebelum mengakses, sila pastikan anda telah log masuk ke CometAPI dan memperoleh kunci API. CometAPI menawarkan harga yang jauh lebih rendah daripada harga rasmi untuk membantu anda menyepadukan.

Kesimpulan

DeepSeek-V3.1 membawa falsafah inferens hibrid praktikal (satu pusat pemeriksaan + tingkah laku pemikiran templat) yang menjadikan percubaan dengan penaakulan gaya rantaian pemikiran dan alat ejen digunakan dengan mudah apabila anda menghormati templat sembang dan keperluan alatan. Gunakan kad model Hugging Face dan nota keluaran DeepSeek sebagai perhentian pertama anda, pilih masa jalan tempatan (Ollama untuk kesederhanaan, llama.cpp untuk kawalan), dan menguji binaan terkuantisasi untuk penggunaan tempatan yang praktikal.