วิธีการเรียกใช้ DeepSeek-V3.1 บนอุปกรณ์ท้องถิ่นของคุณ

CometAPI
AnnaSep 1, 2025
วิธีการเรียกใช้ DeepSeek-V3.1 บนอุปกรณ์ท้องถิ่นของคุณ

DeepSeek-V3.1 เป็นโมเดลการสนทนาแบบผสมผสานระหว่างผู้เชี่ยวชาญ (MoE) ที่เปิดตัวโดย DeepSeek ในเดือนสิงหาคม 2025 ซึ่งรองรับ โหมดอนุมานสองโหมด — โหมด “ไม่คิด” ที่รวดเร็ว และโหมด “คิด” อย่างตั้งใจ — จากจุดตรวจสอบเดียวกัน โมเดลนี้มีให้ใช้งานบน Hugging Face และสามารถรันแบบโลคัลได้ผ่านหลายเส้นทาง (vLLM, Ollama/llama.cpp, GGUF แบบ Ollama หรือการตั้งค่า GPU หลายตัวขนาดใหญ่) ด้านล่างนี้ ผมจะอธิบายข้อกำหนด วิธีการทำงานของโหมดคิด ตัวเลือกการรันแบบโลคัลหลายแบบ (พร้อมโค้ดสั้นๆ ที่รันได้) และสูตร “ปรับใช้โหมดคิด” แบบทีละขั้นตอน พร้อมตัวอย่างสำหรับการเรียกใช้เครื่องมือและเทมเพลตโทเค็น

DeepSeek-V3.1 คืออะไร และเหตุใดจึงสำคัญ?

DeepSeek-V3.1 คือการอัปเดตตระกูล v3 จาก DeepSeek ที่แนะนำ การออกแบบการอนุมานแบบไฮบริด: สามารถรันโมเดลเดียวกันได้ คิด (การปรึกษาหารือหลายขั้นตอน) หรือ ไม่คิด (ตอบตรง เร็วขึ้น) ด้วยการเปลี่ยนเทมเพลตแชท ในด้านสถาปัตยกรรมแล้ว ถือเป็นตระกูล MoE ขนาดใหญ่ (จุดตรวจสอบพื้นฐานอยู่ที่ประมาณ 671 พันล้านพารามิเตอร์ เปิดใช้งานประมาณ 37 พันล้านโทเค็นต่อโทเค็น) พร้อมการฝึกแบบ long-context ที่ขยายเป็น 128 โทเค็น และรองรับการปรับขนาดไมโคร FP8 DeepSeek วางตำแหน่ง V3.1 ให้เป็นรุ่นที่พร้อมสำหรับเอเจนต์: เพิ่มประสิทธิภาพการเรียกใช้เครื่องมือ พัฒนาทักษะเอเจนต์ และประสิทธิภาพการคิดที่สูงขึ้นเมื่อเทียบกับรุ่น R1 รุ่นก่อนหน้า การเปิดตัวนี้ประกาศในเดือนสิงหาคม 2025 และได้รวมเข้ากับ Hugging Face, เครื่องมือ CFD/OSS และคู่มือการติดตั้งบนคลาวด์

โมเดลไฮบริดทำงานอย่างไร (สรุป)

  • จุดตรวจหนึ่งจุด สองเทมเพลต: โหมดการคิดกับโหมดการไม่คิดจะถูกควบคุมโดย เทมเพลตการแชท และ <think>/</think> ข้อตกลงโทเค็นในพรอมต์ การ์ดต้นแบบแสดงคำนำหน้าที่ถูกต้อง
  • การปรับปรุงตัวแทน/เครื่องมือ: การเพิ่มประสิทธิภาพหลังการฝึกอบรมช่วยให้สามารถเรียกเครื่องมือได้อย่างชาญฉลาดมากขึ้น โดยโมเดลนี้คาดหวังรูปแบบ JSON สำหรับการเรียกเครื่องมือที่เข้มงวดเพื่อการดำเนินการเครื่องมือที่ปลอดภัยและกำหนดได้ชัดเจน
  • การแลกเปลี่ยนประสิทธิภาพ: โหมดการคิดจะใช้โทเค็นในการคิดแบบห่วงโซ่ความคิดภายใน และอาจช้ากว่า/ใช้โทเค็นมากกว่า ส่วนโหมดการไม่คิดนั้นเร็วกว่าและถูกกว่า เกณฑ์มาตรฐานในการ์ดแบบจำลองแสดงให้เห็นถึงการปรับปรุงที่สำคัญในเกณฑ์มาตรฐานการใช้เหตุผลและโค้ดสำหรับ V3.1

โครงสร้างของโมเดล

  • กระดูกสันหลังของกระทรวงศึกษาธิการ: จำนวนพารามิเตอร์รวมขนาดใหญ่ที่มีเซ็ตย่อยที่เปิดใช้งานขนาดเล็กต่อโทเค็น (การอนุมานทางเศรษฐกิจ)
  • การฝึกอบรมในบริบทระยะยาว:V3.1 ขยายเฟสบริบทยาวอย่างมีนัยสำคัญ (32k → การฝึกอบรมที่ใหญ่กว่าในเอกสารยาว) เพื่อรองรับหน้าต่าง 128K+ ในบางรุ่น
  • เวิร์กโฟลว์ดั้งเดิมของ FP8:DeepSeek ใช้รูปแบบ FP8 อย่างกว้างขวาง (w8a8 / UE8M0) เพื่อประสิทธิภาพในการชั่งน้ำหนัก/การเปิดใช้งาน มีสคริปต์การแปลงชุมชนหากคุณต้องการ BF16/FP16

ข้อกำหนดในการรัน DeepSeek-V3.1 ในเครื่องมีอะไรบ้าง (ฮาร์ดแวร์ พื้นที่เก็บข้อมูล และซอฟต์แวร์)

วิ่ง เต็ม โมเดล V3.1 (แบบไม่จำกัดปริมาณ) เป็นงานใหญ่ ด้านล่างนี้คือหมวดหมู่การตั้งค่าที่ใช้งานได้จริงและสิ่งที่ต้องการโดยทั่วไป

ถังปฏิบัติ

  • คลัสเตอร์ / ห้องปฏิบัติการวิจัย (แบบจำลองเต็ม):GPU หน่วยความจำสูงหลายตัว (คลาส H100/H800 หรือ GPU Ada/Hopper จำนวนมาก), โหนดหลายตัวที่มี GPU หลายสิบตัว, พื้นที่เก็บข้อมูล NVMe จำนวนมาก (หลายร้อย GB) และเฟรมเวิร์กการอนุมานเฉพาะทาง (SGLang, vLLM, LMDeploy, TRT-LLM)
  • เซิร์ฟเวอร์เดี่ยวระดับไฮเอนด์ (ควอนไทซ์):เป็นไปได้ด้วยการวัดปริมาณอย่างหนัก (INT4/AWQ/AWQ2/gguf) และเฟรมเวิร์กเช่น Ollama (แบบสำเร็จรูป) หรือ GGUF ของชุมชน — ยังคงต้องใช้ GPU RAM ประมาณสิบถึงหลายร้อย GB หรือการออฟโหลด CPU+GPU ที่ชาญฉลาด
  • แล็ปท็อปสำหรับนักพัฒนา / กล่องนักพัฒนา: ไม่สามารถใช้งานได้กับโมเดลแบบเต็ม ให้ใช้ตัวแปรที่กลั่นกรองหรือปรับแต่งอย่างละเอียดขนาดเล็ก หรือเชื่อมต่อกับเซิร์ฟเวอร์ภายใน/อินสแตนซ์ Ollama

รายการตรวจสอบฮาร์ดแวร์ (เชิงปฏิบัติ)

  • GPUs:สำหรับการอนุมานข้อมูลจริงของ V3.1 เต็มรูปแบบ: คลัสเตอร์หลาย GPU (H100 / H800 / Ada Lovelace+) สำหรับการประมวลผล FP8 จำเป็นต้องใช้ GPU ที่มีความสามารถในการประมวลผลและการสนับสนุนไดรเวอร์
  • แรมและที่เก็บข้อมูลคาดว่าจะมีพื้นที่ว่างในดิสก์หลายร้อย GB สำหรับไฟล์โมเดล (หน้าโมเดลแสดงพื้นที่ว่างหลายร้อย GB ขึ้นอยู่กับรูปแบบ/การวัดปริมาณ) พร้อมพื้นที่ทำงานสำหรับรูปแบบที่แปลงแล้ว เมตาดาต้าของ Ollama ระบุพื้นที่ว่างประมาณ 400 GB สำหรับแพ็กเกจ DeepSeek V3.1 Ollama ในไลบรารี
  • เครือข่าย:สำหรับการอนุมานหลายโหนด คุณต้องมีอินเตอร์คอนเนคต์ที่มีเวลาแฝงต่ำ (NVLink / InfiniBand) และเครื่องมือออร์เคสเตรชั่นสำหรับการตั้งค่าเทนเซอร์แบบคู่ขนาน

รายการตรวจสอบซอฟต์แวร์

  • OS:ขอแนะนำ Linux สำหรับเครื่องมืออนุมานของชุมชน (รายการสาธิต DeepSeek-Infer แสดงรายการ Linux/Python)
  • หลาม: 3.10+ (ในตัวอย่าง DeepSeek จำนวนมาก) เวอร์ชันแพ็คเกจทั่วไปจะถูกปักหมุดไว้ในที่เก็บ requirements.txt.
  • กรอบงานและเครื่องมือ (เลือกหนึ่งรายการหรือมากกว่า): SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM หรือ Ollama สำหรับการติดตั้งแบบโลคัลที่ง่ายกว่า แต่ละรายการมีคำแนะนำและการสนับสนุนความแม่นยำ/การวัดปริมาณที่แตกต่างกัน

หมายเหตุการปฏิบัติ: หากคุณมี GPU สำหรับผู้บริโภคเพียงตัวเดียว (เช่น 24–48 GB) คุณอาจต้องใช้ GGUF แบบควอนไทซ์หรือการอนุมานระยะไกล หากคุณมีเวิร์กสเตชันที่มี RAM มากกว่า 128 GB บวกกับคลัสเตอร์ GPU คลาส H100/H200 คุณสามารถกำหนดเป้าหมายการอนุมาน FP8/FP16 ที่มีความเที่ยงตรงสูงกว่าด้วย vLLM ได้

ฉันจะรัน DeepSeek-V3.1 ในเครื่องได้อย่างไร

ด้านล่างนี้เป็นแนวทางปฏิบัติต่างๆ ที่คุณสามารถใช้ได้ ตั้งแต่แนวทางที่ต้องใช้มือ/ยืดหยุ่นที่สุดไปจนถึงแนวทางที่ง่ายที่สุดสำหรับนักพัฒนาคนเดียว ฉันจะให้บทช่วยสอนทีละขั้นตอนและตัวอย่างโค้ด

ตัวเลือก A — การสาธิต DeepSeek-Infer อย่างเป็นทางการ (การพัฒนา / เส้นทางคลัสเตอร์)

นี่คือตัวอย่าง/เดโมของ repo สำหรับการอนุมาน FP8/BF16 ใช้หากคุณวางแผนใช้หลายโหนดหรือต้องการทดลองกับโค้ดอนุมานอย่างเป็นทางการ

  1. โคลน เตรียมสภาพแวดล้อม
git clone https://github.com/deepseek-ai/DeepSeek-V3.git
cd DeepSeek-V3/inference
# Create a dedicated venv / conda env

python -m venv venv && source venv/bin/activate
pip install -r requirements.txt

(รีโป inference/requirements.txt แสดงรายการเวอร์ชันไฟฉาย/ไทรทัน/ทรานส์ฟอร์เมอร์ที่ติดหมุดซึ่งทีมงานแนะนำ)

  1. ดาวน์โหลดแบบจำลองน้ำหนัก
  • ดาวน์โหลดจากหน้าโมเดล Hugging Face (deepseek-ai/DeepSeek-V3.1) แล้ววางไว้ใต้ /path/to/DeepSeek-V3การ์ดรุ่นและบันทึกที่เก็บทั้งสองลิงก์การเก็บข้อมูล Hugging Face อย่างเป็นทางการ
  1. แปลงน้ำหนักสำหรับการสาธิต
# 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
  1. รันการสร้างแบบโต้ตอบ (แบบกระจาย)
torchrun --nnodes 2 --nproc-per-node 8 --node-rank $RANK --master-addr $ADDR \
  generate.py --ckpt-path /path/to/DeepSeek-V3-Demo --config configs/config_671B.json \
  --interactive --temperature 0.7 --max-new-tokens 200

นี่คือตัวอย่างเชิงหลักการจากที่เก็บ DeepSeek สำหรับการรันแบบคลัสเตอร์

ตัวเลือก B — vLLM (แนะนำสำหรับการปรับใช้เซิร์ฟเวอร์และ API ที่เข้ากันได้กับ OpenAI)

vLLM รองรับ DeepSeek ในโหมด FP8/BF16 และมอบเซิร์ฟเวอร์ที่เข้ากันได้กับ OpenAI ให้คุณ ถือเป็นเส้นทางการผลิตยอดนิยมสำหรับโมเดลขนาดใหญ่ เนื่องจากมีการปรับแต่งหน่วยความจำและความเข้ากันได้กับ API

เริ่มเซิร์ฟเวอร์ vLLM ที่จะดึงโมเดลจาก Hugging Face (รูปแบบตัวอย่าง):

# 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

จากนั้นร้องขอการเสร็จสมบูรณ์ด้วย curl หรือไคลเอนต์ที่เข้ากันได้กับ 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}'

สูตรและเอกสาร vLLM ประกอบด้วยตัวอย่างและบันทึกของ DeepSeek เกี่ยวกับความเข้ากันได้ของ FP8 และการทำงานแบบขนานระหว่าง GPU และ Pipeline สำหรับโมเดลขนาดใหญ่ คุณยังคงต้องใช้ GPU หลายตัวหรือตัวแปรแบบควอนไทซ์

ตัวเลือก C — LMDeploy / SGLang / LightLLM และ TensorRT-LLM (ประสิทธิภาพสูง)

ที่เก็บข้อมูล DeepSeek แนะนำอย่างชัดเจน เอสจีแลง, LMดีพลอยและ TensorRT-LLM เป็นเครื่องมือที่ปรับให้เหมาะสมสำหรับ DeepSeek V3 มอบความล่าช้าในการอนุมาน ปริมาณงาน และเคอร์เนล FP8 ที่ดีขึ้น

การเรียกใช้ LMDeploy ทั่วไป (ดูเอกสาร LMDeploy สำหรับ CLI ที่แน่นอน):

# pseudo-example; refer to LMDeploy docs for exact options

lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080

เกณฑ์มาตรฐาน SGLang และสูตรการเปิดตัวมีอยู่ในที่เก็บข้อมูลและในโครงการ SGLang benchmark/deepseek_v3 โฟลเดอร์ ใช้สแต็กเหล่านี้เมื่อคุณควบคุมคลัสเตอร์ GPU และต้องการปริมาณงานการผลิต

ตัวเลือก D — Ollama (เส้นทางการพัฒนาภายในเครื่องที่ง่ายที่สุด มักจะเป็นเครื่องเดียว)

หากคุณต้องการวิธีที่มีแรงเสียดทานน้อยที่สุดในการรัน DeepSeek ในเครื่อง (และคุณสามารถสำรองดิสก์ได้) โอลามา ให้โมเดลแบบแพ็คเกจและ CLI ที่เรียบง่าย (ollama pull, ollama run) DeepSeek-V3.1 ปรากฏในไลบรารี Ollama และสามารถรันในเครื่องได้ (Ollama อาจต้องใช้เวอร์ชันล่าสุด/ก่อนวางจำหน่ายสำหรับฟีเจอร์บางอย่าง)

ตัวอย่าง (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 ย่อรายละเอียดการแจกจ่าย/การวัดปริมาณจำนวนมากออกไป และเป็นวิธีที่ยอดเยี่ยมในการทดสอบพฤติกรรมของโมเดลบนโฮสต์เดียว หมายเหตุ: หน้าโมเดลระบุขนาดแพ็กเกจ ~404GB สำหรับรายการ Ollama ดังนั้นควรวางแผนดิสก์และ RAM ให้เหมาะสม

โหมดการคิดคืออะไรและวิธีใช้

DeepSeek-V3.1 ใช้งาน โทเค็นการคิดแบบไฮบริด แนวทาง: จุดตรวจสอบเดียวกันสามารถดำเนินการได้ใน คิด โหมด (โทเค็น “ห่วงโซ่แห่งความคิด” ภายใน) หรือ ไม่คิด โหมดโดยการสลับเทมเพลตแชท/พรอมต์ โมเดลนี้ใช้โทเค็นที่ชัดเจน เช่น <think> (และปิด </think> ในบางเทมเพลต) เพื่อส่งสัญญาณถึงห่วงโซ่ความคิดภายในเทียบกับการสร้างคำตอบโดยตรง การ์ดตัวอย่างแสดงคำนำหน้าการไม่ใช้ความคิดและการคิด และแสดงให้เห็นว่าเทมเพลตแต่ละแบบแตกต่างกันอย่างไร

ตัวอย่าง: การสร้างข้อความใน Python (ตัวช่วยโทเค็น)

การ์ดโมเดล Hugging Face ประกอบด้วยตัวอย่างที่มีประโยชน์ซึ่งแสดงวิธีการใช้เทมเพลตแชทผ่านโทเค็นไนเซอร์ นี่คือรูปแบบที่แนะนำสำหรับการสร้าง คิด or ไม่คิด คำเตือนที่จัดรูปแบบ:

import transformers
tokenizer = transformers.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=?"}
]

# Thinking mode

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

# Non-thinking mode

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

สวิตซ์ thinking=True เพื่อสร้างคำกระตุ้นที่ใช้ <think> คำนำหน้า; thinking=False สร้างเทมเพลตแบบไม่ต้องคิด โมเดลจะมีพฤติกรรมแตกต่างกัน (การพิจารณาภายในเทียบกับการตอบสนองทันที) ขึ้นอยู่กับแฟล็กนี้

ข้อมูลอ้างอิงด่วน — การแก้ไขปัญหาเล็กๆ น้อยๆ และแนวทางปฏิบัติที่ดีที่สุด

หากคุณใช้หน่วยความจำ GPU หมด: ลองใช้การสร้างแบบควอนไทซ์ (AWQ/q4/INT4) หรือ GGUF ของชุมชน พื้นที่ชุมชนหลายแห่งเผยแพร่การสร้างแบบควอนไทซ์สำหรับการใช้งานในท้องถิ่น นอกจากนี้ Ollama / vLLM ยังสามารถรองรับการสร้างแบบควอนไทซ์ขนาดเล็กได้อีกด้วย

หากคุณต้องการให้โมเดลเรียกเครื่องมือภายนอก: ยอมรับ เครื่องมือโทร schema ในเทมเพลตแชทถูกต้อง ทดสอบรูปแบบ JSON ของเครื่องมือแบบออฟไลน์ และตรวจสอบว่าโค้ดออร์เคสเตรชันของคุณ (ส่วนที่เรียกใช้งานเครื่องมือ) ส่งคืน JSON ที่ผ่านการตรวจสอบและพิมพ์แล้วกลับไปยังโมเดล

หากคุณต้องการบริบทยาว: ใช้ vLLM หรือ SGLang กับปลั๊กอิน long-context; DeepSeek ได้รับการฝึกฝน/ขยายอย่างชัดเจนสำหรับบริบท 32K/128K และเครื่องมือที่เกี่ยวข้องรองรับหน้าต่างนั้น คาดว่าจะต้องแลกกับหน่วยความจำ

ฉันสามารถรัน DeepSeek-V3.1 บนแล็ปท็อปหรือเซิร์ฟเวอร์ขนาดเล็กได้จริงหรือไม่

คำตอบสั้น ๆ : ใช่ แต่ต้องมีคำเตือน การวัดปริมาณแบบชุมชน (AWQ/GGUF/ไดนามิก 1 บิต) ช่วยลดพื้นที่เก็บข้อมูลและหน่วยความจำอย่างมาก และทำให้ผู้เล่นอดิเรกสามารถรันเวอร์ชัน V3.1 บนเดสก์ท็อประดับไฮเอนด์ได้ (อ้างว่ามีพื้นที่ทำงานประมาณ 170 GB) อย่างไรก็ตาม:

  • การแลกเปลี่ยนความเที่ยงตรงกับขนาด: การหาปริมาณเชิงรุกจะลดหน่วยความจำ แต่อาจส่งผลต่อประสิทธิภาพการใช้เหตุผล/โค้ด ทดสอบกับเวิร์กโหลดของคุณ
  • กฎหมายและใบอนุญาต: โมเดลนี้ได้รับอนุญาตภายใต้ MIT ตามการ์ดโมเดล แต่การวัดปริมาณโดยบุคคลที่สามอาจมีใบอนุญาตของตัวเอง โปรดตรวจสอบใบอนุญาตดังกล่าวก่อนใช้งานจริง

สรุป

DeepSeek-V3.1 เป็นก้าวสำคัญสู่โมเดล "ตัวแทน" แบบไฮบริดที่มีพฤติกรรมการคิดแบบชัดเจน/ไม่ใช้ความคิด และการใช้งานเครื่องมือที่ดีขึ้น หากคุณต้องการรันแบบโลคัล ให้เลือกเส้นทางที่ตรงกับฮาร์ดแวร์และระดับความเสี่ยงที่คุณยอมรับได้:

เพื่อการวิจัย: transformers + ตัวปรับค่าความปลอดภัยเชิงปริมาณและเร่งความเร็ว

สำหรับการผลิตและปริมาณงาน: vLLM + หลาย GPU (H100/H200)

สำหรับการทดลองในพื้นที่: Ollama/llama.cpp + GGUFs ชุมชน (รวม + เรียกใช้)

เริ่มต้นใช้งาน

CometAPI เป็นแพลตฟอร์ม API แบบรวมที่รวบรวมโมเดล AI มากกว่า 500 โมเดลจากผู้ให้บริการชั้นนำ เช่น ซีรีส์ GPT ของ OpenAI, Gemini ของ Google, Claude ของ Anthropic, Midjourney, Suno และอื่นๆ ไว้ในอินเทอร์เฟซเดียวที่เป็นมิตรกับนักพัฒนา ด้วยการนำเสนอการตรวจสอบสิทธิ์ การจัดรูปแบบคำขอ และการจัดการการตอบสนองที่สอดคล้องกัน CometAPI จึงทำให้การรวมความสามารถของ AI เข้ากับแอปพลิเคชันของคุณง่ายขึ้นอย่างมาก ไม่ว่าคุณจะกำลังสร้างแชทบ็อต เครื่องกำเนิดภาพ นักแต่งเพลง หรือไพพ์ไลน์การวิเคราะห์ที่ขับเคลื่อนด้วยข้อมูล CometAPI ช่วยให้คุณทำซ้ำได้เร็วขึ้น ควบคุมต้นทุน และไม่ขึ้นอยู่กับผู้จำหน่าย ทั้งหมดนี้ในขณะที่ใช้ประโยชน์จากความก้าวหน้าล่าสุดในระบบนิเวศ AI

นักพัฒนาสามารถเข้าถึงได้ ดีพซีค-V3.1 ผ่าน CometAPI รุ่นล่าสุดที่ระบุไว้เป็นข้อมูล ณ วันที่เผยแพร่บทความ เริ่มต้นด้วยการสำรวจความสามารถของโมเดลใน สนามเด็กเล่น และปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด ก่อนเข้าใช้งาน โปรดตรวจสอบให้แน่ใจว่าคุณได้เข้าสู่ระบบ CometAPI และได้รับรหัส API แล้ว โคเมทเอพีไอ เสนอราคาที่ต่ำกว่าราคาอย่างเป็นทางการมากเพื่อช่วยคุณบูรณาการ

อ่านเพิ่มเติม

500+ โมเดลใน API เดียว

ลดราคาสูงสุด 20%