SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor · อัปเดตเมื่อ 2026-10-26

วิธีแก้ปัญหา Ollama context deadline exceeded

พบข้อผิดพลาด context deadline exceeded ใน Ollama ใช่หรือไม่ ปัญหานี้เกิดจาก Go timeout ระหว่างการดึงโมเดลหรือเรียกใช้งาน API เรียนรู้วิธีตรวจสอบสาเหตุจาก Client, Nginx หรือการโหลดโมเดล

ความหมายที่แท้จริงของ "context deadline exceeded"

ข้อผิดพลาด context deadline exceeded ใน Ollama คือการแจ้งเตือนว่าหมดเวลา (timeout) โค้ดภาษา Go บางส่วนได้กำหนดเส้นตาย (deadline) ให้กับการทำงานหนึ่งไว้ แต่การทำงานนั้นไม่เสร็จสิ้นภายในเวลาที่กำหนด เส้นตายจึงหมดลง โดยส่วนใหญ่การทำงานนั้นคือคำขอที่กำลังรอโมเดลประมวลผล ไม่มีส่วนใดของระบบล่มและไม่มีไฟล์ใดเสียหาย งานยังคงดำเนินการอยู่ขณะที่เวลาหมดลง

ถ้อยคำนี้มาจากแพ็กเกจ context มาตรฐานของ Go ซึ่งเป็นเบาะแสที่มีประโยชน์ในตัวมันเอง ไคลเอนต์ภาษา Python ที่สร้างบน httpx จะแสดงข้อผิดพลาด httpx.ReadTimeout แทน ส่วนเบราว์เซอร์จะแสดงข้อผิดพลาดเครือข่ายทั่วไป หากคุณกำลังอ่านข้อความนี้ แสดงว่าโปรแกรมภาษา Go ได้ยกเลิกการรอคอยไปแล้ว ไม่ว่าจะเป็นเครื่องมือบรรทัดคำสั่งของ Ollama, ตัวเซิร์ฟเวอร์ Ollama เอง หรือแอปพลิเคชันภาษา Go ที่เรียกใช้งาน API (application programming interface)

เส้นตายไม่ได้เกิดขึ้นเฉพาะตอนที่โมเดลกำลังตอบกลับเท่านั้น ข้อความเดียวกันนี้ยังปรากฏขึ้นระหว่างการดาวน์โหลด เช่น ollama pull หรือการดึงข้อมูล (pull) ที่ ollama run เริ่มต้นขึ้นเมื่อโมเดลยังไม่ได้อยู่ในดิสก์ ปัญหา Ollama #17484 ซึ่งรายงานในเวอร์ชัน 0.32.5 แสดงให้เห็นว่า ollama run ของโมเดลจาก Hugging Face พิมพ์บรรทัด pulling ออกมาแล้วตามด้วย Error: context deadline exceeded โดยที่ log ของเซิร์ฟเวอร์แสดงว่าการดึงข้อมูล blob จาก hf.co ล้มเหลวด้วยข้อผิดพลาดเดียวกัน หากผลลัพธ์ของคุณหยุดลงทันทีหลังจากบรรทัด pulling แสดงว่าเส้นตายหมดลงที่การดาวน์โหลด ดังนั้นให้ลองดึงข้อมูลใหม่อีกครั้งและตรวจสอบเส้นทางเครือข่ายไปยัง registry ก่อนที่จะเปลี่ยนการตั้งค่าใดๆ ด้านล่างนี้

เมื่อโมเดลอยู่ในดิสก์แล้ว จะมี 5 เลเยอร์ที่เกี่ยวข้อง โดย 3 เลเยอร์มีการกำหนดเส้นตายของตัวเอง ได้แก่ ไคลเอนต์ของคุณ, ระยะเวลา timeout ในการโหลดโมเดลของเซิร์ฟเวอร์ และ reverse proxy ส่วนอีก 2 เลเยอร์ที่เหลือคือ keep_alive และ num_ctx ไม่ได้กำหนดเส้นตายไว้ แต่เป็นตัวตัดสินว่างานจำนวนเท่าใดที่ต้องประมวลผลให้เสร็จภายในครั้งเดียว ทั้งหมดนี้ล้มเหลวในจุดที่ต่างกันและต้องการวิธีแก้ไขที่ต่างกัน งานสำคัญของคุณคือการระบุว่าเลเยอร์ใดที่เป็นต้นเหตุของข้อผิดพลาด

  1. HTTP client ของคุณ ซึ่งกำหนดงบประมาณเวลาคงที่ให้กับคำขอ
  2. ระยะเวลา timeout ในการโหลดโมเดลของเซิร์ฟเวอร์ Ollama ซึ่งจะทำงานในขณะที่โมเดลขนาดใหญ่กำลังถูกอ่านออกจากดิสก์เป็นครั้งแรก
  3. keep_alive ซึ่งจะยกเลิกการโหลดโมเดลระหว่างคำขอ ทำให้การเรียกใช้งานครั้งถัดไปต้องเสียเวลาโหลดใหม่อีกครั้ง
  4. num_ctx ที่มีขนาดใหญ่พอจนทำให้การประมวลผล prompt เพียงอย่างเดียวใช้เวลาหลายนาทีบนเครื่องที่ไม่มี GPU
  5. Reverse proxy เช่น nginx หรือ Traefik ซึ่งตัดการเชื่อมต่อก่อนที่ Ollama จะตอบกลับ

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

ทดสอบกับ API โดยตรงเพื่อตัดปัญหาเรื่อง proxy

ให้รันคำสั่ง request บนเซิร์ฟเวอร์โดยตรงไปยัง Ollama โดยไม่ผ่าน proxy ใดๆ ทั้งสิ้น

time curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Why is the sky blue?",
  "stream": false
}' | head -c 400

curl ไม่มีการกำหนดระยะเวลา timeout รวมไว้ในตัว แต่จะมีเพียง connect timeout เท่านั้น ดังนั้นคำสั่งนี้จะรอจนกว่า Ollama จะประมวลผลเสร็จ ซึ่งจะช่วยแยกปัญหาออกเป็นสองส่วน หากได้รับ JSON body กลับมา แสดงว่า Ollama ตอบสนองได้ปกติ และปัญหาเรื่องระยะเวลาเกิดจากส่วนประกอบที่อยู่หน้า Ollama แต่หากคำสั่งนี้ค้างไปนานหลายนาที แสดงว่าความล่าช้าเกิดขึ้นภายใน Ollama เอง และ proxy ของคุณก็ไม่มีส่วนเกี่ยวข้อง

จากนั้นให้ส่ง request เดิมผ่าน public URL ของคุณและจับเวลา

curl -s -o /dev/null -w '%{http_code} %{time_total}\n' \
  -X POST https://llm.example.com/api/generate \
  -d '{"model": "llama3.1:8b", "prompt": "hi", "stream": false}'

หากสถานะ 504 ปรากฏขึ้นหลังจากผ่านไปเป็นจำนวนวินาทีที่ลงตัวอย่างน่าสงสัย เช่น 60.0 หรือ 30.0 แสดงว่าเกิดปัญหา proxy timeout เนื่องจาก proxy มักใช้ค่าเริ่มต้นที่เป็นตัวเลขกลมๆ โดยปกติแล้วโมเดลจะไม่ประมวลผลเสร็จสิ้นที่เวลา 60.000 วินาทีพอดีเป๊ะสองครั้งติดต่อกัน หากการเรียกใช้งานโดยตรงถูกปฏิเสธทันทีแทนที่จะช้า แสดงว่าคุณมีปัญหาเรื่อง listener ไม่ใช่ปัญหาเรื่อง deadline ซึ่งกรณีนี้ครอบคลุมอยู่ในหัวข้อ ที่อยู่ซึ่ง Ollama ผูกไว้บนพอร์ต 11434

ตรวจสอบ log ของเซิร์ฟเวอร์ขณะที่คำขอดำเนินการ

เปิด session ที่สองแล้วติดตาม log ของบริการ จากนั้นส่งคำขออีกครั้ง

journalctl -u ollama --no-pager --follow --pager-end

การเริ่มต้นแบบ cold start ที่ปกติจะแสดง log การโหลดโมเดล ตามด้วยการเริ่ม runner และการให้บริการคำขอ หากการโหลดล้มเหลวจะมีลักษณะดังนี้ใน release ปัจจุบัน ซึ่งตรวจสอบเทียบกับ source code เวอร์ชัน 0.40.11 ในเดือนตุลาคม 2026 และนี่คือข้อความที่ระบุถึงการหมดเวลาโหลดของเซิร์ฟเวอร์เอง:

timed out waiting for llama-server to start - <last error from the runner>

build รุ่นเก่า เช่น 0.12.0 จะใช้ข้อความว่า timed out waiting for llama runner to start - progress 0.00 - ไม่ว่าจะกรณีใด กระบวนการโหลดโมเดลไม่เสร็จสิ้นภายในระยะเวลาที่เซิร์ฟเวอร์กำหนด ในข้อความรุ่นเก่า ตัวเลขความคืบหน้าจะบอกว่าโหลดไปได้ไกลแค่ไหน และ 0.00 หมายความว่า runner ไม่รายงานสถานะใดๆ ออกมาก่อนถึงกำหนดเวลา ซึ่งมักหมายความว่าไฟล์กำลังถูกอ่านอยู่หรือเครื่องกำลังทำ swapping สำหรับ build ปัจจุบันจะตัดตัวเลขออกและต่อท้ายด้วยข้อความ error ล่าสุดของ runner ซึ่งจะว่างเปล่าหากไม่มี error เกิดขึ้น หาก log แจ้งเตือนว่าการเชื่อมต่อของ client ปิดลงก่อนที่ llama-server จะโหลดเสร็จ แสดงว่าผู้เรียกใช้งาน (client ของคุณหรือ proxy ที่อยู่ด้านหน้า) ยอมแพ้ไปก่อนและทำให้การโหลดถูกยกเลิก หากต้องการรายละเอียดเพิ่มเติมระหว่างการโหลด ให้ restart บริการโดยตั้งค่า OLLAMA_DEBUG=1 แล้วลองใหม่อีกครั้ง

วัดผลว่าความล่าช้าเกิดจากการโหลดหรือการสร้างคำตอบ

Ollama จะรายงานเวลาที่ใช้ด้วยตัวเอง คุณจึงไม่ต้องคาดเดาส่วนนี้

ollama run --verbose llama3.1:8b "Why is the sky blue?"

หลังจากแสดงคำตอบ Ollama จะพิมพ์ total duration, load duration, prompt eval count, prompt eval rate, eval count และ eval rate ออกมา ให้ลองรันคำสั่งสองครั้ง ในการรันครั้งที่สองค่า load duration ควรลดลงจนเกือบเป็นศูนย์ เนื่องจากโมเดลถูกโหลดไว้ในหน่วยความจำแล้ว หากค่าไม่ลดลง แสดงว่าโมเดลถูกยกเลิกการโหลดระหว่างการรันทั้งสองครั้ง ซึ่งเป็นกรณี keep_alive ที่จะกล่าวถึงต่อไป

ตัวเลขชุดเดียวกันจะถูกส่งกลับมาจาก API ในออบเจกต์ JSON สุดท้ายในชื่อ load_duration, prompt_eval_duration และ eval_duration เอกสารระบุว่าระยะเวลาทั้งหมดจะส่งกลับมาในหน่วยนาโนวินาที ดังนั้นให้หารด้วย 10^9 เพื่อแปลงเป็นวินาที

curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Why is the sky blue?",
  "stream": false
}' | python3 -c 'import json,sys; d=json.load(sys.stdin); print({k: round(v/1e9, 2) for k, v in d.items() if k.endswith("_duration")})'

ให้พิจารณาตัวเลขที่มากที่สุด หาก load_duration มีค่าสูงที่สุด แสดงว่าคุณมีปัญหาเรื่องการโหลดโมเดล ให้ข้ามไปดูสองส่วนถัดไป หาก prompt_eval_duration มีค่าสูงที่สุด แสดงว่าต้นทุนอยู่ที่การประมวลผล prompt ให้ข้ามไปที่ส่วน num_ctx หาก eval_duration มีค่าสูงที่สุด แสดงว่าโมเดลกำลังสร้างคำตอบช้าบนฮาร์ดแวร์นี้ และไม่มีการตั้งค่า timeout ใดที่จะแก้ไขได้ ให้ลดความยาวของผลลัพธ์ด้วย num_predict หรือเปลี่ยนไปใช้โมเดลที่มีขนาดเล็กลง

เพิ่มค่า OLLAMA_LOAD_TIMEOUT หลังจากตรวจสอบเวอร์ชันของคุณ

ตัวแปรเซิร์ฟเวอร์ที่ควบคุมส่วนนี้คือ OLLAMA_LOAD_TIMEOUT ในซอร์สโค้ดเวอร์ชัน 0.40.11 ซึ่งตรวจสอบเมื่อเดือนตุลาคม 2026 ได้ระบุไว้ว่าตัวแปรนี้กำหนดระยะเวลาที่อนุญาตให้การโหลดโมเดลหยุดชะงักก่อนที่จะยกเลิก โดยมีค่าเริ่มต้นอยู่ที่ 5 นาที และทุกสัญญาณความคืบหน้าของการโหลดจะเริ่มนับเวลาใหม่ ตัวแปรนี้ไม่มีอยู่ในรุ่นเก่าอย่าง 0.3.0 ดังนั้นโปรดอ่านค่าเริ่มต้นสำหรับรุ่นของคุณเองแทนการอ้างอิงจากบทความใดๆ รวมถึงบทความนี้ด้วย ให้พิมพ์เวอร์ชันออกมาก่อน

ollama --version

จากนั้นเปิดซอร์สโค้ดสำหรับแท็กนั้นโดยเฉพาะที่ https://github.com/ollama/ollama/blob/<your version>/envconfig/config.go และค้นหา OLLAMA_LOAD_TIMEOUT ค่าที่อยู่ในไฟล์นั้นคือค่าเริ่มต้นที่ binary ของคุณถูกคอมไพล์มา ให้ตั้งค่าของคุณเองผ่านทาง systemd drop-in

sudo systemctl edit ollama.service

เพิ่มตัวแปรภายใต้ส่วน [Service] ซึ่งเป็นวิธีที่เอกสารของ Ollama แนะนำสำหรับ Linux:

[Service]
Environment="OLLAMA_LOAD_TIMEOUT=15m"
Environment="OLLAMA_KEEP_ALIVE=-1"
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment

คำสั่งสุดท้ายจะพิมพ์สภาพแวดล้อมที่ service ได้รับจริง หากผลลัพธ์ว่างเปล่า แสดงว่า drop-in ถูกบันทึกไว้นอกเครื่องหมายของ editor หรืออยู่ภายใต้ชื่อส่วนที่ไม่ถูกต้อง ทำให้สิ่งที่คุณตั้งค่าไว้ไม่มีผล โปรดทำความเข้าใจให้ชัดเจนว่าสิ่งนี้ช่วยอะไรคุณได้บ้าง: การเพิ่มค่า timeout สำหรับการโหลดจะช่วยป้องกันไม่ให้เซิร์ฟเวอร์ยกเลิกการทำงาน แต่ไม่ได้ทำให้การทำงานเร็วขึ้น หากโมเดลไม่พอดีกับหน่วยความจำ เครื่องจะทำการ swap ทำให้การโหลดช้าลงอย่างมาก และการเพิ่มตัวเลขให้มากขึ้นเพียงแค่ช่วยเลื่อนเวลาที่ระบบจะล้มเหลวออกไปเท่านั้น

เหตุใดคำขอแรกหลังจากหยุดพักจึงทำงานช้า

Ollama จะยกเลิกการโหลดโมเดลที่ไม่ได้ใช้งานออกจากหน่วยความจำเพื่อคืนพื้นที่ว่าง การตั้งค่า keep_alive จะเป็นตัวกำหนดช่วงเวลานี้ เอกสารของ Ollama ระบุค่าเริ่มต้นไว้ที่ 5 นาที (ตรวจสอบเมื่อเดือนตุลาคม 2026) ดังนั้นแอปแชทที่ถูกใช้งานชั่วโมงละครั้งจึงต้องโหลดโมเดลใหม่ทุกครั้งที่มีการส่งข้อความ และทุกข้อความจะต้องรอการเริ่มต้นระบบใหม่ (cold start) คำขอที่หมดเวลา (timeout) คือคำขอแรกหลังจากช่วงเวลาที่ไม่มีการใช้งาน ซึ่งตรงกับรูปแบบที่ผู้ใช้มักรายงานว่าเป็นปัญหาแบบสุ่ม

ตรวจสอบว่าขณะนี้มีโมเดลใดอยู่ในหน่วยความจำบ้าง:

ollama ps
curl -s http://127.0.0.1:11434/api/ps

หากรายการว่างเปล่าหรือมีเวลาหมดอายุเหลือเพียงไม่กี่นาที นั่นเป็นการยืนยันสถานะดังกล่าว keep_alive รองรับการระบุระยะเวลาในรูปแบบสตริง เช่น "10m" หรือ "24h", การระบุจำนวนวินาทีเป็นตัวเลขปกติ, 0 เพื่อยกเลิกการโหลดทันที หรือใช้ตัวเลขติดลบเพื่อคงโมเดลไว้ในหน่วยความจำอย่างถาวร คุณสามารถตั้งค่าแยกตามคำขอ หรือตั้งค่า OLLAMA_KEEP_ALIVE ไว้ที่ตัว service เพื่อใช้กับทุกคำขอ อย่างไรก็ตาม ค่าที่ระบุในคำขอจะมีผลเหนือกว่า โดยเอกสารของ Ollama ระบุว่าพารามิเตอร์ API keep_alive จะแทนที่การตั้งค่า OLLAMA_KEEP_ALIVE ดังนั้นไคลเอนต์ที่ส่งค่า keep_alive ของตนเองมาด้วยจะยังคงยกเลิกการโหลดโมเดลตามกำหนดเวลาของไคลเอนต์นั้นๆ

curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "keep_alive": -1
}'

การส่งคำขอที่มีชื่อโมเดลแต่ไม่มี prompt จะเป็นการโหลดโมเดลนั้นขึ้นมาแล้วตอบกลับ นี่เป็นวิธีที่ระบุไว้ในเอกสารสำหรับการเตรียมความพร้อม (warm up) ให้กับเซิร์ฟเวอร์หลังจากรีบูต และควรนำไปใส่ไว้ใน systemd unit ขนาดเล็ก เพื่อไม่ให้ผู้ใช้ต้องรอการ cold start ครั้งแรกหลังรีบูต ต้นทุนที่ต้องแลกคือการใช้ทรัพยากรจริง: โมเดลที่ถูกตรึงไว้ (pinned model) จะยึดครองหน่วยความจำตลอดเวลา ดังนั้นบนเซิร์ฟเวอร์ขนาดเล็ก คุณจะสามารถตรึงโมเดลได้เพียงหนึ่งโมเดล ไม่ใช่สี่โมเดล การคงโมเดลไว้ในหน่วยความจำระหว่างคำขอ จะอธิบายรายละเอียดเกี่ยวกับการคำนวณหน่วยความจำและการสร้าง unit สำหรับการ warm-up

เหตุใด num_ctx ขนาดใหญ่จึงทำให้เกิด timeout ก่อนได้รับ token แรก

ก่อนที่โมเดลจะเขียนข้อความใดๆ โมเดลจะต้องอ่าน prompt ทั้งหมดของคุณก่อน ขั้นตอนนี้เรียกว่า prefill ซึ่งเป็นสิ่งที่ prompt eval ใช้วัดค่า num_ctx เป็นตัวกำหนดความยาวของบริบท (context length) ซึ่งส่งผลสองอย่างพร้อมกัน คือจำกัดจำนวน token ที่โมเดลจะนำมาพิจารณา และกำหนดขนาดของ KV cache (key value cache) ที่เซิร์ฟเวอร์ต้องจัดสรรไว้ล่วงหน้า ทั้งสองส่วนนี้ทำให้ภาระงานเพิ่มขึ้น

บนเซิร์ฟเวอร์ที่ใช้ CPU เพียงอย่างเดียว ขั้นตอน prefill จะทำงานช้าและเป็นสัดส่วนโดยตรงกับจำนวน token ใน prompt การวางเอกสารขนาดยาวลงในแชทอาจทำให้ต้องรอ prefill นานหลายนาทีโดยที่ฝั่งไคลเอนต์ไม่เห็นผลลัพธ์ใดๆ เนื่องจากกระบวนการ streaming ยังไม่เริ่มต้น ไคลเอนต์จะพบกับกำหนดเวลาที่ตั้งไว้และรายงานว่า context deadline exceeded ทั้งที่เซิร์ฟเวอร์กำลังประมวลผลอยู่ตลอดเวลา คุณสามารถพิสูจน์ได้ด้วยตัวเลขจากส่วนก่อนหน้า ให้ส่ง prompt ขนาดยาวแล้วอ่านค่า prompt_eval_count และ prompt_eval_duration ซึ่ง Ollama นิยามว่าเป็นเวลาที่ใช้ในการประมวลผล token ใน prompt ที่ยังไม่ได้ถูกแคช หากใช้เวลาหลายนาทีโดยที่ค่า eval_duration มีขนาดเล็ก นั่นคือขั้นตอน prefill เนื่องจากนับเฉพาะ token ที่ยังไม่ได้แคชเท่านั้น การส่ง prompt เดิมซ้ำในโมเดลที่ยังคงโหลดอยู่ในหน่วยความจำอาจใช้เวลาน้อยลงมาก ดังนั้นควรเปรียบเทียบจากการรันครั้งแรกเท่านั้น หากต้องการทราบว่า cache ที่ใหญ่ขึ้นมีต้นทุนอย่างไร ให้รัน prompt ด้วย "options": {"num_ctx": 2048} แล้วตามด้วย 32768 จากนั้นอ่านค่า load_duration ประกอบด้วย เนื่องจากเวลาที่ใช้ในการโหลดโมเดลจะถูกรายงานในส่วนนี้ ไม่ใช่ใน prompt_eval_duration

ค่าเริ่มต้นของเซิร์ฟเวอร์มาจาก OLLAMA_CONTEXT_LENGTH และค่า num_ctx ต่อคำขอในออบเจกต์ options จะเข้ามาแทนที่ค่าเริ่มต้นนั้น ข้อผิดพลาดที่พบบ่อยคือการปรับค่าขึ้นไปจนถึงค่าสูงสุดที่โมเดลรองรับเพียงเพราะว่าค่าสูงสุดนั้นมีอยู่จริง เนื่องจากหน่วยความจำที่จัดสรรให้ KV cache อาจดันโมเดลออกจาก RAM และทำให้ระบบที่เคยทำงานได้ปกติกลายเป็นการใช้ swap แทน การเลือก num_ctx ให้เหมาะสมกับหน่วยความจำจริงของคุณ มีรายละเอียดเกี่ยวกับการคำนวณขนาดหน่วยความจำ

เหตุใด nginx จึงส่งคืนข้อผิดพลาด 504 Gateway Time-out

เอกสารของ nginx ระบุถึง proxy_read_timeout โดยมีค่าเริ่มต้นเป็น 60s และ log ของข้อผิดพลาดจะระบุสาเหตุไว้อย่างชัดเจน:

upstream timed out (110: Connection timed out) while reading response header from upstream

รายละเอียดที่สำคัญอยู่ในเอกสารของ nginx: ค่า timeout "จะถูกกำหนดเฉพาะระหว่างการอ่านข้อมูลสองครั้งที่ต่อเนื่องกัน ไม่ใช่สำหรับระยะเวลาการส่งข้อมูลทั้งหมด" การตอบสนองแบบ streaming จะรีเซ็ตเวลาใหม่ในทุกๆ chunk ดังนั้นการแชทแบบ streaming จึงไม่ถูกตัดการเชื่อมต่อ แต่คำขอที่ใช้ "stream": false จะไม่ส่งข้อมูลใดๆ ออกมาจนกว่าคำตอบจะเสร็จสมบูรณ์ ดังนั้นการประมวลผลทั้งหมดต้องเสร็จสิ้นภายในช่วงเวลาดังกล่าว นี่คือเหตุผลว่าทำไมโมเดลเดียวกันจึงทำงานได้ในหน้าต่างแชท แต่กลับเกิด timeout เมื่อเรียกผ่านสคริปต์

location / {
    proxy_pass http://127.0.0.1:11434;
    proxy_http_version 1.1;
    proxy_set_header Host $host;
    proxy_read_timeout 600s;
    proxy_send_timeout 600s;
    proxy_buffering off;
}
sudo nginx -t && sudo systemctl reload nginx

proxy_buffering off มีความสำคัญต่อการทำ streaming หากเปิดใช้งาน buffering ไว้ nginx จะรวบรวมการตอบสนองและส่งมอบให้เมื่อเสร็จสิ้น ทำให้ token ไม่ปรากฏออกมาทีละตัว และ stream ที่ทำงานอยู่จะดูเหมือนค้างไป

Traefik ใช้การควบคุมแบบเดียวกันนี้ใน ServersTransport ที่ router ใช้งาน

http:
  serversTransports:
    ollama:
      forwardingTimeouts:
        dialTimeout: "30s"
        responseHeaderTimeout: "0s"
        idleConnTimeout: "60s"

responseHeaderTimeout ครอบคลุมถึงการรอ response header หลังจากเขียนคำขอเสร็จสิ้น โดยค่าศูนย์หมายถึงไม่มีการจำกัดเวลา บริการจะต้องอ้างอิง transport ด้วยชื่อผ่านทาง serversTransport: ollama มิฉะนั้นคุณอาจกำลังแก้ไขบล็อกที่ไม่มีการเรียกใช้งานจริง

การทำ Quantisation ขนาดเล็กช่วยให้โหลดโมเดลได้เร็วขึ้นเนื่องจากมีข้อมูลที่ต้องอ่านน้อยลง

Quantisation คือระดับความละเอียดที่ใช้จัดเก็บค่าน้ำหนัก (weights) ของโมเดล ความละเอียดที่ต่ำกว่าหมายถึงไฟล์ที่มีขนาดเล็กลง และกระบวนการโหลดโมเดลส่วนใหญ่คือการอ่านไฟล์จากดิสก์เข้าสู่หน่วยความจำ

แผนภูมิPublished download sizes for llama3.1 8B on the ollama.com library, October 2026
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "q4_K_M",
    "download_size_gb": 4.9
  },
  {
    "label": "q8_0",
    "download_size_gb": 8.5
  },
  {
    "label": "fp16",
    "download_size_gb": 16
  }
]

ขนาดเหล่านี้เป็นข้อมูลที่เผยแพร่บนหน้าเพจของโมเดล ไม่ใช่การวัดผลจากเครื่องทดสอบจริง รุ่น 8B มาตรฐานมีขนาด 4.9 GB ในขณะที่รุ่นความละเอียดเต็ม (full precision) ของโมเดลเดียวกันมีขนาด 16 GB ซึ่งต้องใช้การอ่านข้อมูลมากกว่า 3 เท่าและใช้หน่วยความจำในการจัดเก็บมากกว่า 3 เท่าเช่นกัน บนเซิร์ฟเวอร์เช่าที่ใช้พื้นที่จัดเก็บข้อมูลร่วมกัน ความแตกต่างนี้อาจเป็นปัจจัยตัดสินว่าการโหลดจะเสร็จสมบูรณ์หรือจะเกิด timeout เสียก่อน การคำนวณว่าโมเดลขนาดใดเหมาะสมกับ RAM ของคุณ คือขั้นตอนที่ควรตรวจสอบก่อนที่จะดึงข้อมูลขนาดใหญ่ใดๆ ลงมาใช้งาน

สิ่งที่ควรปรับเปลี่ยนบนเซิร์ฟเวอร์เช่า

ให้ดำเนินการตามลำดับที่การวัดผลระบุไว้ โดยปรับทีละรายการและรันคำสั่งวัดเวลาซ้ำหลังจากปรับแต่ละครั้ง

  1. ตรึงโมเดลด้วย OLLAMA_KEEP_ALIVE=-1 และวอร์มโมเดลขณะบูต เพื่อให้ผู้ใช้งานไม่ต้องแบกรับภาระค่าใช้จ่ายด้านเวลาในการโหลด จากนั้นตรวจสอบว่าไม่มีไคลเอนต์ใดส่งค่า keep_alive ของตนเองมาด้วย เพราะค่าที่ส่งมาในคำขอจะไปแทนที่การตั้งค่าของเซิร์ฟเวอร์
  2. ลดค่า num_ctx ลงให้เหลือเท่าที่ prompt ของคุณต้องการจริง ซึ่งจะช่วยลดระยะเวลา prefill และคืนหน่วยความจำที่ KV cache เคยจองไว้
  3. เลือกใช้ quantisation ที่เล็กลง เพื่อให้การโหลดอ่านข้อมูลจำนวนไบต์ที่น้อยลง และทำให้โมเดลมีพื้นที่เหลือสำหรับ cache
  4. เพิ่มค่า proxy_read_timeout ใน nginx หรือ responseHeaderTimeout ใน Traefik และปิดการใช้งาน buffering เพื่อให้ token ที่ถูกสตรีมส่งไปถึงไคลเอนต์ได้ทันที
  5. เพิ่มค่า timeout ในไคลเอนต์ของคุณ เนื่องจากโปรแกรมที่เขียนด้วย Go หรือ Python ซึ่งกำหนดงบประมาณเวลาไว้ที่ 30 วินาที จะล้มเหลวเมื่อเจอกับโมเดลที่ต้องใช้เวลาคิดนานกว่านั้น

ยังมีอีกหนึ่งสาเหตุที่ซ่อนอยู่เบื้องหลังสิ่งเหล่านี้ Ollama ให้บริการคำขอได้จำกัดจำนวนในคราวเดียวและจะนำคำขอที่เหลือเข้าคิว ดังนั้นผู้เรียกใช้งานรายที่สองอาจต้องรออยู่ในคิวจนกระทั่งกำหนดเวลาของตนเองหมดลง โดยที่ไม่ได้เกิดจากโมเดลทำงานช้าแต่อย่างใด log ของเซิร์ฟเวอร์จะแสดงให้เห็นว่าคำขอนั้นถูกประมวลผลล่าช้าแทนที่จะล้มเหลว สิ่งที่เกิดขึ้นเมื่อหลายคนใช้งาน Ollama บนเซิร์ฟเวอร์เดียวกัน ครอบคลุมการตั้งค่าการทำงานแบบขนาน และ การติดตั้งพื้นฐานบน VPS ครอบคลุมการตั้งค่า service ที่การปรับแต่งเหล่านี้อ้างอิงถึง

FAQ

"context deadline exceeded" ใน Ollama หมายความว่าอย่างไร

หมายความว่าระยะเวลาที่กำหนดไว้สิ้นสุดลงก่อนที่งานที่อยู่ภายใต้การควบคุมจะเสร็จสิ้น ส่วนใหญ่งานดังกล่าวคือคำขอที่รอการประมวลผลจากโมเดล แต่ข้อผิดพลาดเดียวกันนี้อาจปรากฏขึ้นระหว่างการดาวน์โหลดโมเดล ใน ollama pull หรือการดึงข้อมูลที่ ollama run เริ่มต้นขึ้น วลีนี้มาจากแพ็กเกจ context ของภาษา Go ดังนั้นโปรแกรมที่เขียนด้วย Go จึงแสดงข้อความนี้ออกมา ไม่ว่าจะเป็นเครื่องมือบรรทัดคำสั่ง Ollama, เซิร์ฟเวอร์ Ollama หรือแอปพลิเคชัน Go ที่เรียกใช้ API นี่คือปัญหา timeout ดังนั้นจึงไม่มีส่วนใดเสียหายหรือผิดปกติ หากผลลัพธ์หยุดลงทันทีหลังจาก pulling บรรทัด ให้ถือว่าเป็นปัญหาการดาวน์โหลด มิฉะนั้นขั้นตอนถัดไปคือการหาว่าเลเยอร์ใดเป็นผู้กำหนดเส้นตาย เนื่องจากไคลเอนต์, การโหลดโมเดล และ reverse proxy ต่างก็กำหนดเส้นตายของตนเอง ในขณะที่ keep_alive และ num_ctx เป็นตัวตัดสินว่าต้องทำงานมากน้อยเพียงใดภายในระยะเวลานั้น

ฉันควรเพิ่มค่า timeout ของไคลเอนต์หรือของ Ollama

ให้วัดผลก่อน ส่งคำขอด้วย curl บนตัวเซิร์ฟเวอร์เองโดยตรงไปยัง http://127.0.0.1:11434 เนื่องจาก curl ไม่ได้กำหนดขีดจำกัดเวลาโดยรวมไว้ หากการเรียกนั้นส่งคืน JSON body แสดงว่า Ollama กำลังตอบสนองและเส้นตายนั้นเป็นของไคลเอนต์หรือพร็อกซีของคุณ ดังนั้นให้เพิ่มค่าที่จุดนั้น หากการเรียกนั้นค้างเช่นกัน แสดงว่าความล่าช้าเกิดขึ้นภายใน Ollama และฟิลด์ load_duration กับ prompt_eval_duration ในการตอบกลับจะบอกคุณว่าโมเดลกำลังโหลดหรือกำลังอ่าน prompt ของคุณอยู่

ทำไมคำขอแรกถึง timeout แต่คำขอถัดไปกลับทำงานได้ปกติ

Ollama จะยกเลิกการโหลดโมเดลที่ไม่ได้ใช้งานเพื่อคืนหน่วยความจำตามกำหนดเวลาที่ตั้งไว้โดย keep_alive ค่าเริ่มต้นที่ระบุไว้คือ 5 นาที ซึ่งตรวจสอบ ณ เดือนตุลาคม 2026 คำขอแรกหลังจากช่วงที่ไม่ได้ใช้งานจะเป็นการโหลดโมเดลจากดิสก์ใหม่และต้องรอเวลาเริ่มต้น (cold start) ในขณะที่คำขอที่ส่งตามมาทันทีจะพบว่าโมเดลยังอยู่ในหน่วยความจำและส่งผลลัพธ์กลับมาได้อย่างรวดเร็ว ให้รัน ollama ps เพื่อดูว่ามีอะไรโหลดอยู่บ้างและจะหมดอายุเมื่อใด ตั้งค่า OLLAMA_KEEP_ALIVE=-1 เพื่อคงโมเดลไว้ในหน่วยความจำ และยอมรับว่าหน่วยความจำจะถูกใช้งานตลอดเวลา ไคลเอนต์ที่ส่ง keep_alive ของตนเองจะเขียนทับการตั้งค่าดังกล่าว ดังนั้นควรตรวจสอบไคลเอนต์ของคุณด้วย

ทำไมถึงล้มเหลวเฉพาะตอนที่ผ่าน nginx

nginx ระบุ proxy_read_timeout โดยมีค่าเริ่มต้นเป็น 60s ซึ่ง timeout นี้มีผลระหว่างการอ่านสองครั้งที่ต่อเนื่องกันมากกว่าที่จะเป็นผลรวมของทั้งการตอบกลับ การตอบกลับแบบ streaming จะรีเซ็ตค่านี้ทุกครั้งที่มี chunk ใหม่ ในขณะที่คำขอที่ส่งด้วย "stream": false จะต้องเสร็จสิ้นภายในหน้าต่างเวลาเดียว นี่คือเหตุผลว่าทำไมหน้าต่างแชทถึงใช้งานได้แต่สคริปต์กลับล้มเหลว ให้มองหา upstream timed out (110: Connection timed out) while reading response header from upstream ใน log ข้อผิดพลาดของ nginx จากนั้นเพิ่มค่า proxy_read_timeout และตั้งค่า proxy_buffering off

การเพิ่มค่า OLLAMA_LOAD_TIMEOUT จะช่วยให้โหลดเร็วขึ้นหรือไม่

ไม่ช่วย มันเปลี่ยนเพียงระยะเวลาที่เซิร์ฟเวอร์ยอมให้การโหลดค้างไว้ก่อนที่จะยอมแพ้และบันทึก timed out waiting for llama-server to start หรือ timed out waiting for llama runner to start ในรุ่นเก่า หากโมเดลไม่พอดีกับหน่วยความจำ เครื่องจะทำการ swap ทำให้การโหลดช้าลงอย่างมาก และการเพิ่มค่า timeout เพียงแค่เลื่อนเวลาที่เกิดความล้มเหลวออกไปโดยไม่ได้แก้ไขปัญหา ตรวจสอบค่าเริ่มต้นสำหรับรุ่นของคุณโดยรัน ollama --version และอ่าน envconfig/config.go ที่แท็กนั้น จากนั้นให้ถือว่าการโหลดที่ต้องใช้เวลาหลายนาทีเป็นสัญญาณว่าควรดึงโมเดลที่มีการทำ quantisation ขนาดเล็กลงมาใช้แทน

บทความนี้มีประโยชน์หรือไม่