วิธีใช้ Local LLMs เป็น API

แล็ปท็อปของคุณสามารถรันโมเดลขนาด 70B พารามิเตอร์ได้ โดยใช้ปลายทาง (endpoint) ที่มีรูปแบบเหมือน OpenAI ซึ่งคุณใช้ในการนำขึ้นสู่เวอร์ชันใช้งานจริง เพียงแค่เปลี่ยน base URL เดียว โค้ดของคุณก็ยังคงทำงานได้ตามปกติ การเปลี่ยนแปลงเพียงครั้งเดียวนี้จะช่วยให้สามารถพัฒนาแบบออฟไลน์ได้ ไม่มีค่าใช้จ่ายต่อโทเค็น และมีช่องทางส่วนตัวสำหรับข้อมูลที่ถูกควบคุม นี่คือเหตุผลที่ Hacker News ได้ผลักดันแนวคิด "Local AI needs to be the norm" ให้มีคะแนนเพิ่มขึ้นจาก 633 เป็น 1,760 คะแนนภายในหนึ่งวัน บทความด้านล่างนี้จะแสดงวิธีเลือกรันไทม์ เปิดเผยปลายทาง ชี้ไคลเอ็นต์ของคุณไปยังปลายทางนั้น และทดสอบการทำงานทั้งหมดด้วย Apidog ก่อนที่จะโปรโมทการเปลี่ยนแปลงใดๆ ไปยังโมเดลที่โฮสต์ไว้

สรุปย่อ (TL;DR)

คุณสามารถรัน Local LLM API บนแล็ปท็อปของคุณได้ด้วย Ollama, vLLM หรือ llama.cpp ซึ่งทั้งหมดนี้มีปลายทาง REST ที่เข้ากันได้กับ OpenAI เพียงเปลี่ยน base_url เป็น http://localhost:11434/v1 ในไคลเอ็นต์ OpenAI ที่คุณมีอยู่ โค้ดเดิมก็จะทำงานได้กับ Llama 3.3, DeepSeek V4 หรือ Qwen 3.6 โดยไม่ต้องแก้ไขใดๆ จัดการการทำงานทั้งหมดจาก Apidog เพื่อให้การทดสอบสถานการณ์ของคุณเหมือนกันทั้งในสภาพแวดล้อมภายในเครื่องและสภาพแวดล้อมแบบโฮสต์

บทนำ

ชุด API ของ LLM ภายในเครื่องได้พัฒนาจากของเล่นสำหรับการวิจัยไปสู่เครื่องมือใช้งานประจำวันภายในสิบแปดเดือน Apple ได้เปิดตัว M3 Max ที่มาพร้อมหน่วยความจำรวม 128 GB Ollama มียอดดาวน์โหลดรายสัปดาห์ถึงหนึ่งล้านครั้ง vLLM มีดาว GitHub ทะลุ 30,000 ดวง อย่างไรก็ตาม การเปลี่ยนแปลงที่ใหญ่ที่สุดคือในเชิงสังคม ปัจจุบันทุกรันไทม์หลักๆ รองรับรูปแบบ /v1/chat/completions ของ OpenAI คุณไม่จำเป็นต้องดูแลเส้นทางไคลเอ็นต์สองเส้นทางอีกต่อไป การเรียกใช้ SDK เดียวกันสามารถส่งไปยัง localhost หรือ api.openai.com โดยขึ้นอยู่กับตัวแปรสภาพแวดล้อมเพียงตัวเดียว

สิ่งนี้มีความสำคัญสำหรับนักพัฒนา API เพราะเครื่องมือที่มีอยู่ของคุณยังคงทำงานได้ตามปกติ เทมเพลตคำขอของคุณใน Apidog ชี้ไปที่ https://api.openai.com/v1/chat/completions เพียงแค่สลับตัวแปร base URL กด Send คุณก็จะได้รับ JSON เดียวกันกลับมาจากโมเดลที่รันอยู่บน GPU ของคุณเอง ไม่ต้องมีสคีมาใหม่ ไม่ต้องมีขั้นตอนการยืนยันตัวตนใหม่ หากคุณติดตาม ค่าใช้จ่าย API ต่อฟีเจอร์ อยู่แล้ว คุณสามารถทำ A/B Test ระหว่างโมเดลภายในเครื่องกับโมเดลที่โฮสต์ไว้ และดูค่าใช้จ่ายที่ลดลงในขณะที่ความหน่วงอาจเพิ่มขึ้นเล็กน้อย

คู่มือนี้จะอธิบายเกี่ยวกับการเลือกรันไทม์ การตั้งค่าเซิร์ฟเวอร์ การเชื่อมต่อไคลเอ็นต์ การทดสอบสถานการณ์ ข้อดีข้อเสียของการควอนไทซ์ และตารางเปรียบเทียบค่าใช้จ่ายกับความหน่วงสำหรับโมเดลสี่ตัวในปัจจุบัน ตัวอย่างโค้ดได้รับการทดสอบกับ Ollama 0.6 และ vLLM 0.7 บน macOS 15.4 และ Ubuntu 24.04 สำหรับตัวเลือกที่หลากหลายยิ่งขึ้น โปรดดู Best local LLMs 2026 การอ้างอิงภายนอกสำหรับทุกข้อความอยู่ด้านล่าง

ทำไม LLM ภายในเครื่องจึงมีประโยชน์สำหรับนักพัฒนา API

คุณเผยแพร่โค้ดที่เรียกใช้ LLM คุณยังดีบักโค้ดนั้นบนเครื่องบิน ในงานประชุมที่มี Wi-Fi ไม่ดี และภายในเครือข่ายลูกค้าที่บล็อกการเชื่อมต่อไปยัง *.openai.com LLM API ภายในเครื่องให้สภาพแวดล้อมการพัฒนาที่สะท้อนการผลิตจริงโดยไม่ต้องพึ่งพาเครือข่าย

ประเด็นความเป็นส่วนตัวเป็นสิ่งที่สำคัญที่สุด HIPAA, GDPR และกฎหมาย AI ของสหภาพยุโรป ล้วนถือว่าพร้อมต์เป็นข้อมูลผู้ใช้ทันทีที่พวกมันรวมบันทึกผู้ป่วย สัญญา หรือตัวระบุชีวมาตร การส่งเพย์โหลดดังกล่าวไปยังปลายทางที่โฮสต์ไว้จะสร้างความสัมพันธ์ในฐานะผู้ประมวลผลข้อมูลที่คุณต้องจัดทำเอกสาร ตรวจสอบ และต่ออายุ โมเดลที่ไม่เคยออกจากฮาร์ดแวร์ของคุณจะข้ามขั้นตอนเอกสารเหล่านั้นไปทั้งหมด แนวทางของ European Data Protection Board ปี 2024 เกี่ยวกับการประมวลผล AI ระบุว่า การอนุมานบนอุปกรณ์จะช่วยลดภาระผูกพันในการถ่ายโอนข้อมูลข้ามพรมแดนส่วนใหญ่ภายใต้มาตรา 44

ค่าใช้จ่ายที่สะสมไปในทิศทางตรงกันข้าม ทีมที่รันโทเค็นพร้อมต์ 50 ล้านโทเค็นต่อวันผ่าน GPT-5.5 Instant จะจ่ายประมาณ 250 ดอลลาร์ต่อวัน ที่อัตรา 5 ดอลลาร์ต่อล้านโทเค็น ปริมาณเดียวกันบน M3 Max studio ราคา 4,500 ดอลลาร์ จะหักลบกลบหนี้เป็นศูนย์หลังจากใช้งานเต็มที่สิบแปดวัน โดยไม่คิดค่าไฟฟ้า คุณสามารถอ่านรายละเอียดตัวเลขเหล่านี้ได้ใน วิธีใช้ GPT-5.5 Instant และนำหลักคณิตศาสตร์เดียวกันไปใช้กับปริมาณงานของคุณเอง

เหตุผลที่สามคือความแน่นอน (determinism) โมเดลที่โฮสต์ไว้อาจมีการเปลี่ยนแปลงน้ำหนักโดยที่คุณไม่รู้ ตัวอย่างเช่น หน้าการเลิกใช้งานโมเดลของ OpenAI ระบุการเลิกใช้งานสแนปช็อตถึงสิบเอ็ดครั้งในสิบสองเดือนที่ผ่านมา โมเดลภายในเครื่องเป็นไฟล์บนดิสก์ มันจะให้ logits เดียวกันทั้งในวันนี้และอีกสามปีข้างหน้า ความเสถียรนี้มีความสำคัญเมื่อชุดการทดสอบการถดถอยของคุณขึ้นอยู่กับผลลัพธ์ของ LLM ปลายทางที่เข้ากันได้กับ OpenAI ได้เปลี่ยนเกมเพราะคุณไม่จำเป็นต้องจ่ายภาษีการผสานรวมสำหรับความเสถียรนั้นอีกต่อไป SDK ที่คุณใช้อยู่แล้วก็ยังคงทำงานได้

สามรันไทม์ที่มาพร้อมปลายทางที่เข้ากันได้กับ OpenAI

มีรันไทม์สี่ตัวที่โดดเด่นในพื้นที่ LLM API ภายในเครื่องในปี 2026 โดยสามตัวมาพร้อมกับเซิร์ฟเวอร์ REST ที่เข้ากันได้กับ OpenAI ตั้งแต่เริ่มต้น ส่วนตัวที่สี่คือ llama.cpp จะมาพร้อมกับเซิร์ฟเวอร์ดังกล่าวเป็นส่วนหนึ่งของไบนารี llama-server ให้เลือกตามปริมาณงาน ไม่ใช่ตามความนิยม

Ollama

Ollama คือจุดเริ่มต้นที่ง่ายที่สุด ไบนารีเดียว CLI เดียว เซิร์ฟเวอร์ HTTP เดียวบนพอร์ต 11434 มันมุ่งเป้าไปที่นักพัฒนาที่รันโมเดลเดียวบนเครื่องเดียว และจัดการการดาวน์โหลดโมเดล, การควอนไทซ์ GGUF และการสร้างเทมเพลตพร้อมต์ให้คุณ

## install on macOS
brew install ollama
ollama serve &
ollama pull llama3.3:70b-instruct-q4_K_M
ollama run llama3.3:70b-instruct-q4_K_M

เมื่อ ollama serve ทำงานแล้ว ปลายทางที่เข้ากันได้กับ OpenAI จะอยู่ที่ http://localhost:11434/v1 มันรองรับการสนทนา, embeddings และการสตรีม อัตราการประมวลผลสูงสุดบน M3 Max ด้วยโมเดล 70B Q4_K_M อยู่ที่ประมาณ 12 โทเค็นต่อวินาที โมเดลขนาดเล็กจะอยู่ที่ 80 ถึง 120 โทเค็นต่อวินาที Ollama เป็นตัวเลือกที่เหมาะสมสำหรับการพัฒนาสำหรับผู้ใช้คนเดียว, การสาธิต และ CI runners

vLLM

vLLM เป็นตัวเลือกสำหรับระดับการผลิต มันใช้ PagedAttention และ continuous batching เพื่อเพิ่มอัตราการประมวลผลให้สูงกว่ารันเนอร์แบบธรรมดาถึงสองถึงสี่เท่า โดยจะทำงานบนพอร์ต 8000 โดยค่าเริ่มต้น และเปิดเผย API ที่เข้ากันได้กับ OpenAI ที่ /v1 คุณสามารถอ่านรายละเอียดสถาปัตยกรรมได้ในเอกสาร vLLM ที่อ้างอิง Kwon et al. SOSP 2023 ด้านล่าง

pip install vllm
vllm serve meta-llama/Llama-3.3-70B-Instruct \
  --port 8000 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 8192

บน H100 ตัวเดียว vLLM สามารถให้บริการ Llama 3.3 70B ได้ที่ประมาณ 2,400 โทเค็นต่อวินาทีสำหรับการร้องขอที่เกิดขึ้นพร้อมกัน มันต้องการ CUDA GPU หรือการ์ด AMD ROCm รุ่นใหม่ และไม่ทำงานบน Apple Silicon ซึ่งทำให้มันไม่เหมาะสำหรับแล็ปท็อป แต่เหมาะสำหรับคลัสเตอร์การพัฒนาที่ใช้ร่วมกัน

llama.cpp

llama.cpp เป็นรันไทม์ C++ ที่เป็นจุดเริ่มต้นของระบบนิเวศ GGUF มันทำงานได้ทุกที่ตั้งแต่ Raspberry Pi 5 ไปจนถึงเครื่องที่มี RTX-5090 สองตัว ไบนารี llama-server ของมันรองรับรูปแบบ OpenAI บน /v1/chat/completions

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j LLAMA_METAL=1
./llama-server -m models/llama-3.3-70b-q4_k_m.gguf \
  --port 8080 --host 0.0.0.0 -c 8192 -ngl 99

แฟล็ก -ngl 99 จะทำการ offload เลเยอร์ทั้งหมดไปยัง GPU llama.cpp ให้คุณควบคุมการควอนไทซ์, การทำแบตช์ และการแมปหน่วยความจำได้อย่างเต็มที่ มันเป็นตัวเลือกที่เหมาะสมเมื่อคุณต้องการบีบอัดโมเดลให้พอดีกับ VRAM ขนาด 16 GB หรือทดสอบฮาร์ดแวร์ที่แปลกใหม่

LM Studio และ Jan ห่อหุ้ม llama.cpp ไว้ใน GUI และยังเปิดเผยปลายทาง OpenAI บนพอร์ตที่กำหนดค่าได้ พวกมันมีประโยชน์สำหรับผู้ใช้ที่ไม่ใช่ด้านเทคนิคในทีมของคุณที่ต้องการทดสอบพร้อมต์โดยไม่ต้องใช้เทอร์มินัล

การตรวจสอบง่ายๆ ด้วย Python ว่าปลายทางทำงานได้:

from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
resp = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[{"role": "user", "content": "Reply with the word OK only."}],
)
print(resp.choices[0].message.content)

หากคุณเห็น OK นั่นหมายความว่ารันไทม์, พอร์ต และข้อตกลง SDK ทั้งหมดตรงกัน คุณพร้อมที่จะเชื่อมต่อปลายทางนี้เข้ากับเครื่องมือของคุณแล้ว

ทดสอบ LLM ภายในเครื่องของคุณด้วย Apidog

API ของ LLM ภายในเครื่องจะมีประโยชน์ก็ต่อเมื่อชุดการทดสอบของคุณสามารถเรียกใช้งานได้ในลักษณะเดียวกับที่เรียกใช้งานในเวอร์ชันใช้งานจริง Apidog จัดการเรื่องนี้ด้วยตัวแปรสภาพแวดล้อมบนเทมเพลตคำขอ ซึ่งหมายความว่าโปรเจกต์เดียวสามารถครอบคลุมเป้าหมายทั้งสองได้

ขั้นตอนมีห้าขั้นตอน

1. เปิดโปรเจกต์ Apidog ของคุณและสร้างสภาพแวดล้อมใหม่ชื่อ Local เพิ่มตัวแปร BASE_URL ที่มีค่า http://localhost:11434/v1 เพิ่ม API_KEY ที่มีค่า ollama บันทึก
2. โคลนสภาพแวดล้อม OpenAI ที่มีอยู่ของคุณ เปลี่ยนชื่อเป็น Production คง BASE_URL เป็น https://api.openai.com/v1 และ API_KEY เป็นคีย์ที่คุณโฮสต์ไว้
3. ในการร้องขอใดๆ ที่เรียกใช้ปลายทางแชท ให้แทนที่โฮสต์ที่ระบุค่าตายตัวด้วย {{BASE_URL}} และส่วนหัวการยืนยันตัวตนด้วย Bearer {{API_KEY}} URL คำขอจะกลายเป็น {{BASE_URL}}/chat/completions
4. สร้างการทดสอบสถานการณ์ที่ส่งคำขอ, ยืนยันว่า choices[0].message.role == "assistant", ยืนยันว่า choices[0].message.content ไม่ว่างเปล่า และยืนยันว่า usage.total_tokens > 0 บันทึกสถานการณ์
5. รันสถานการณ์กับสภาพแวดล้อม Local สลับดรอปดาวน์สภาพแวดล้อมเป็น Production รันอีกครั้ง การยืนยันควรจะผ่านสำหรับทั้งสองกรณี

สถานการณ์เดียวกันนี้ยังทำหน้าที่เป็น smoke test สำหรับการอัปเกรดรันไทม์ หลังจาก ollama pull บนแท็กใหม่ ให้รันสถานการณ์ Local ซ้ำ หากรูปร่างการตอบกลับเปลี่ยนแปลงไป คุณจะตรวจจับได้ก่อนที่โค้ดแอปพลิเคชันใดๆ จะแตะน้ำหนักใหม่ รูปแบบนี้ยังขยายไปถึง การทดสอบ AI agents ที่เรียกใช้ multi-step APIs

สำหรับการใช้งานแบบโปรแกรม OpenAI Python SDK จะสลับเป้าหมายด้วยอาร์กิวเมนต์คีย์เวิร์ดเดียว:

import os
from openai import OpenAI

def get_client():
    if os.getenv("ENV") == "local":
        return OpenAI(
            base_url="http://localhost:11434/v1",
            api_key="ollama",
        )
    return OpenAI(api_key=os.environ["OPENAI_API_KEY"])

client = get_client()
response = client.chat.completions.create(
    model=os.getenv("MODEL", "llama3.3:70b-instruct-q4_K_M"),
    messages=[
        {"role": "system", "content": "You are a JSON-only assistant."},
        {"role": "user", "content": "Return {\"status\": \"ok\"}."},
    ],
    response_format={"type": "json_object"},
)
print(response.choices[0].message.content)

รูปแบบ JavaScript ก็คล้ายกันนี้:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.ENV === "local"
    ? "http://localhost:11434/v1"
    : "https://api.openai.com/v1",
  apiKey: process.env.ENV === "local" ? "ollama" : process.env.OPENAI_API_KEY,
});

const resp = await client.chat.completions.create({
  model: process.env.MODEL || "llama3.3:70b-instruct-q4_K_M",
  messages: [{ role: "user", content: "Say hi." }],
});
console.log(resp.choices[0].message.content);

เชื่อมต่อ scenario runner ของ Apidog เข้ากับ CI ของคุณโดยการส่งออกโปรเจกต์เป็นคอลเลกชัน apidog-cli และเรียกใช้ apidog run ใน GitHub Actions ตัวรันจะคืนค่าที่ไม่ใช่ศูนย์เมื่อการยืนยันล้มเหลว ซึ่งจะทำให้บิลด์ล้มเหลวทันทีที่สัญญาภายในเครื่องหรือโฮสต์มีการเปลี่ยนแปลง วิศวกร QA สามารถเชื่อมต่อโฟลว์เดียวกันนี้เข้ากับ ไปป์ไลน์การทดสอบ API ที่มีอยู่ได้

เทคนิคขั้นสูงและเคล็ดลับ

การควอนไทซ์ (Quantization) เป็นกลไกที่กำหนดว่าโมเดล 70B จะพอดีกับแล็ปท็อปของคุณหรือไม่ รูปแบบ GGUF เก็บน้ำหนักที่ 8, 6, 5, 4, 3 หรือ 2 บิตต่อพารามิเตอร์ Q4_K_M เป็นค่าเริ่มต้นด้วยเหตุผลบางประการ มันลดคะแนนลง 0.6 เปอร์เซ็นต์ในเกณฑ์มาตรฐาน MMLU เทียบกับ FP16 และลดขนาดโมเดล 70B จาก 140 GB เหลือ 40 GB Q8 ทำให้คุณอยู่ในระยะ 0.1 จุดจาก FP16 แต่เพิ่มพื้นที่ดิสก์และ RAM เป็นสองเท่า Q2_K ช่วยประหยัดพื้นที่ แต่ความซับซ้อนที่ลดลงจะเห็นได้ชัดเจนในงานที่มีบริบทที่ยาว เลือก Q4_K_M สำหรับการแชท, Q8 สำหรับการสร้างโค้ด และ Q5_K_M เมื่อคุณมี RAM เพียงพอและต้องการระยะปลอดภัย

GPU offload ผ่านแฟล็ก -ngl ใน llama.cpp หรือตัวเลือก num_gpu ใน Ollama จะควบคุมจำนวนเลเยอร์ของ Transformer ที่อยู่บน GPU ตั้งค่าให้สูงที่สุดเท่าที่ VRAM ของคุณจะอนุญาต แต่ละเลเยอร์ที่กลับไปทำงานบน CPU จะลดอัตราการประมวลผลลงประมาณ 30 เปอร์เซ็นต์ บนการ์ด 24 GB โมเดล 70B Q4 จะใส่ได้ 40 จาก 80 เลเยอร์ บน 48 GB คุณสามารถใส่ได้ทั้งสแต็ก

การแมปหน่วยความจำ (mmap) ถูกเปิดใช้งานโดยค่าเริ่มต้นใน llama.cpp และ Ollama ช่วยให้ระบบปฏิบัติการสามารถโหลดน้ำหนักได้ตามต้องการ แทนที่จะจัดสรรโมเดลทั้งหมดเมื่อเริ่มต้น ควรเปิดใช้งานไว้เว้นแต่คุณจะทำงานในคอนเทนเนอร์ที่มีข้อจำกัดหน่วยความจำที่เข้มงวด หากปิด mmap ความหน่วงของโทเค็นแรกจะลดลงประมาณ 200 ms แต่การใช้งาน RAM จะเพิ่มขึ้นเป็นสองเท่า

การทำแบตช์ (Batching) คือจุดแข็งของ vLLM ส่งคำขอพร้อมกัน 32 รายการ แล้ว vLLM จะจัดกลุ่มคำขอเหล่านั้นเป็นการประมวลผล GPU ครั้งเดียว อัตราการประมวลผลจะเพิ่มขึ้นเกือบเป็นเส้นตรงตามขีดจำกัดการคำนวณของ GPU ตั้งค่า --max-num-seqs 64 สำหรับแล็ปท็อปที่มีหน่วยความจำ CPU ที่ใช้ร่วมกัน และ --max-num-seqs 256 สำหรับฮาร์ดแวร์ระดับ H100

การสตรีมการตอบสนองช่วยลดความหน่วงที่รับรู้ได้ลงครึ่งหนึ่ง ตั้งค่า stream=True ใน OpenAI SDK และเซิร์ฟเวอร์จะส่งโทเค็นออกมาทันทีที่สร้างเสร็จ ไบต์แรกจะมาถึงภายใน 200 ถึง 500 ms แทนที่จะต้องรอการเสร็จสมบูรณ์ทั้งหมด ทุกรันไทม์ในคู่มือนี้รองรับคุณสมบัตินี้

Modelfile ของ Ollama ช่วยให้คุณสามารถใส่ระบบพร้อมต์, อุณหภูมิ และลำดับการหยุดลงในโมเดลที่ตั้งชื่อไว้ เพื่อให้โค้ดแอปพลิเคชันของคุณยังคงสะอาดตา รัน ollama create my-assistant -f Modelfile เพียงครั้งเดียว ไคลเอ็นต์ของคุณก็จะชี้ไปที่ my-assistant แทนที่จะทำซ้ำระบบพร้อมต์ในทุกคำขอ

ข้อผิดพลาดที่พบบ่อย

• ฮาร์ดโค้ด http://localhost:11434 ในโค้ดเวอร์ชันใช้งานจริง ควรใช้ตัวแปรสภาพแวดล้อม
• ลืมว่าโมเดลภายในเครื่องไม่ได้บังคับใช้ max_tokens มันจะสร้างโทเค็นได้ถึง 4,096 โทเค็นอย่างไม่มีปัญหา ตั้งค่า stop sequence ไว้
• รัน Ollama และรันไทม์อื่นบนพอร์ตเดียวกัน ทั้งสองใช้พอร์ตเริ่มต้นที่สะอาดตา แต่พอร์ตที่กำหนดเองอาจชนกันโดยไม่มีการแจ้งเตือน
• ข้ามส่วนหัว Authorization Ollama จะไม่สนใจ แต่ vLLM ที่มี --api-key จะปฏิเสธคำขอที่ไม่ได้รับการยืนยันตัวตนด้วยรหัส 401
• โหลดโมเดล Q4 แล้วคาดหวังคุณภาพระดับ GPT-5.5 ในการคำนวณทางคณิตศาสตร์ การควอนไทซ์จะลดความสามารถในการให้เหตุผลลงเร็วที่สุด

ภายในเครื่องเทียบกับโฮสต์: การคำนวณค่าใช้จ่ายและความหน่วง

ตัวเลขด้านล่างนี้สมมติว่าใช้ M3 Max ที่มีหน่วยความจำรวม 128 GB สำหรับการใช้งานภายในเครื่อง และราคาปัจจุบันที่เปิดเผยต่อสาธารณะสำหรับปลายทางที่โฮสต์ไว้ เวลาในการรับโทเค็นแรก (TTFT) วัดได้จากการเริ่มต้นแบบ cold, ไม่มี batching, และใช้พร้อมต์ขนาด 1,024 โทเค็น

คอลัมน์ของโมเดลที่โฮสต์ชนะเรื่องความหน่วงเสมอ ส่วนคอลัมน์ของโมเดลภายในเครื่องชนะเรื่องค่าใช้จ่ายทันทีที่คุณมีปริมาณการใช้งานประมาณ 10 ล้านโทเค็นต่อวัน และยังชนะเรื่องความเป็นส่วนตัวตั้งแต่คำขอแรก สำหรับการพัฒนา คุณมักจะต้องการใช้โมเดลภายในเครื่องเกือบตลอดเวลา สำหรับการใช้งานจริงที่ต้องเผชิญกับผู้ใช้ คุณมักจะต้องการใช้โมเดลที่โฮสต์ไว้ เว้นแต่การจำแนกข้อมูลของคุณจะห้ามไว้

รูปแบบที่เป็นประโยชน์: รันแบบภายในเครื่องในระหว่างวงจรการพัฒนาภายใน (inner dev loop), สลับไปใช้แบบโฮสต์ใน staging, และรักษาสถานะของทั้งสองเป้าหมายให้ "เขียว" ใน CI การทดสอบสถานการณ์ของ Apidog จากส่วนด้านบนรองรับรูปแบบนี้ด้วยการสลับสภาพแวดล้อมเพียงครั้งเดียว สำหรับเกณฑ์มาตรฐานที่ละเอียดขึ้นของโมเดลแต่ละตัว โปรดดู วิธีรัน DeepSeek V4 ภายในเครื่อง และ คู่มือการใช้งาน DeepSeek V4 ฉบับดั้งเดิม

กรณีการใช้งานจริง

ทีมปฏิบัติตามกฎระเบียบด้านเทคโนโลยีการเงินในสิงคโปร์ใช้ Ollama บนแล็ปท็อปของวิศวกรเพื่อร่างรายงานกิจกรรมที่น่าสงสัย พร้อมต์เหล่านี้มีหมายเลขบัญชีและรูปแบบการทำธุรกรรมที่ไม่สามารถออกจากประเทศได้ภายใต้กฎ MAS ปลายทางที่โฮสต์ไว้ซึ่งพวกเขาใช้ในการผลิตจะได้รับพร้อมต์เดียวกันในเวอร์ชันที่ถูกแก้ไข Apidog scenarios ยืนยันว่าโปรแกรมแก้ไขข้อมูลทำงานกับทุกคำขอก่อนที่จะออกจาก localhost

สตูดิโอเกมในสตอกโฮล์มฝึกอบรมนักออกแบบฝึกงานเกี่ยวกับการออกแบบพร้อมต์ (prompt engineering) ด้วยอินสแตนซ์ Qwen 3.6 ภายในเครื่อง ซึ่งฟรี ทำงานแบบออฟไลน์ และเป็นไปไม่ได้ที่จะรั่วไหลเนื้อเรื่องของเกมถัดไปให้กับบุคคลที่สาม โปรเจกต์เดียวกันนี้ถูกนำไปใช้งานกับ Gemini 3 Flash ในเวอร์ชันที่ใช้งานจริงโดยการเปลี่ยนตัวแปรสภาพแวดล้อมเพียงตัวเดียว พวกเขานำ คู่มือ Gemini 3 Flash API กลับมาใช้ใหม่สำหรับการเชื่อมต่อในเวอร์ชันใช้งานจริง

สตาร์ทอัพด้านการดูแลสุขภาพรัน vLLM บน A100 ที่เช่ามาภายในเครือข่ายโรงพยาบาลของลูกค้า ปลายทางนี้ไม่เคยเห็น Public DNS การทดสอบการผสานรวมของพวกเขาจะรันจาก Jenkins agent ใน VLAN เดียวกัน โดยใช้ OpenAI SDK เดียวกันกับที่พวกเขาใช้ในเครื่อง โค้ดเดียวกัน เป้าหมายการปรับใช้สามรายการ ชุดสถานการณ์เดียว

บทสรุป

ชุด API ของ LLM ภายในเครื่องได้พัฒนาไปอย่างรวดเร็ว คุณสามารถย้ายพร้อมต์ของคุณออกจากปลายทางที่โฮสต์ไว้ได้โดยไม่ต้องเขียนโค้ดไคลเอ็นต์ การทดสอบ หรือ CI ของคุณใหม่ ขั้นตอนทั้งห้าที่จะทำให้สิ่งนี้เป็นจริง:

• เลือก Ollama สำหรับแล็ปท็อป, vLLM สำหรับคลัสเตอร์การพัฒนาที่ใช้ร่วมกัน, llama.cpp สำหรับงบประมาณหน่วยความจำที่จำกัด
• เปิดเผยปลายทางที่เข้ากันได้กับ OpenAI และยืนยันด้วยคำสั่ง curl เพียงบรรทัดเดียว
• ย้าย base_url และ api_key ไปยังตัวแปรสภาพแวดล้อม เพื่อให้โค้ดเดียวกันสามารถเรียกใช้ได้ทั้งภายในเครื่องและแบบโฮสต์
• สร้างการทดสอบสถานการณ์ใน Apidog ที่ทำงานได้เหมือนกันทั้งสองสภาพแวดล้อม
• ดูตารางเปรียบเทียบค่าใช้จ่ายกับความหน่วง และเลือกเป้าหมายที่เหมาะสมสำหรับแต่ละปริมาณงาน

สัญญาณจาก Hacker News ที่ผลักดันให้แนวคิด “Local AI needs to be the norm” ทะลุ 1,700 คะแนน เป็นผลมาจากการเติบโตนี้ เมื่อพื้นผิว API มีความเสถียร เครื่องมือสำหรับนักพัฒนาทุกตัวก็พร้อมที่จะรองรับ ดาวน์โหลด Apidog และชี้สภาพแวดล้อมหนึ่งไปยัง http://localhost:11434/v1 เพื่อดูว่าวงจรการพัฒนานั้นรวดเร็วเพียงใด หากคุณยังไม่ได้เลือกรุ่นโมเดล ให้เริ่มต้นด้วย Best local LLMs 2026 และหากคุณต้องการเจาะลึกเกี่ยวกับการทดสอบโฟลว์ของเอเจนต์บนปลายทางเหล่านี้ โปรดอ่าน How to test AI agents API