AI Agent, LLM และ AI Assistant ต่างกันอย่างไร สรุปชัดเจน

AI agent, LLM และ AI assistant แตกต่างกันอย่างไร

AI agent, LLM และ AI assistant คือสามเลเยอร์ที่ประกอบกันเป็นสแต็กเดียว วิธีแยกความแตกต่างคือการพิจารณาว่าแต่ละส่วนต้องการทรัพยากรใดจากเซิร์ฟเวอร์ LLM (large language model) คือไฟล์น้ำหนัก (weights) ที่ต้องการ RAM และพลังการประมวลผล ส่วน assistant คือโมเดลดังกล่าวที่ถูกครอบด้วยอินเทอร์เฟซแชท มีบัญชีผู้ใช้และประวัติการสนทนา ซึ่งมักจะรันอยู่บนฮาร์ดแวร์ของผู้ให้บริการรายอื่นเสมอ ในขณะที่ agent คือ assistant ที่มีเครื่องมือ (tools) และลูปการทำงาน (loop) เพิ่มเข้ามา รวมถึงมีการถือครอง credential ซึ่งเป็นเหตุผลที่ทำให้มันต้องรันอยู่บนเครื่องที่เปิดทำงานตลอดเวลา

เนื้อหาส่วนใหญ่ที่อธิบายเรื่องนี้มักจบลงแค่การให้คำจำกัดความ แต่คำจำกัดความเหล่านี้มีความสำคัญก็ต่อเมื่อพิจารณาว่าแต่ละเลเยอร์มีค่าใช้จ่ายอย่างไร เลเยอร์แรกมีค่าใช้จ่ายด้าน RAM เลเยอร์ถัดมามีค่าใช้จ่ายด้าน public URL และ TLS (transport layer security) ส่วนเลเยอร์สุดท้ายมีค่าใช้จ่ายด้าน credential และเมื่อใดที่ agent ได้ใช้ credential ไปแล้ว นั่นหมายถึง credential นั้นเป็นสิ่งที่คุณต้องหมุนเวียน (rotate) ใหม่ทันที

LLM คือค่าน้ำหนัก และค่าน้ำหนักต้องการ RAM

LLM คือไฟล์ที่เก็บชุดตัวเลข คุณดาวน์โหลดไฟล์นั้นมา จากนั้น runtime จะโหลดไฟล์เข้าสู่หน่วยความจำ และมันจะตอบสนองคำขอทีละรายการ ข้อตกลงการทำงานนั้นจำกัด: รับข้อความเข้าและส่งข้อความออก โมเดลไม่มีหน่วยความจำระหว่างการเรียกใช้งาน ไม่มีนาฬิกา ไม่มีสิทธิ์เข้าถึงเครือข่าย และไม่มีวิธีเปิดไฟล์ใดๆ ทุกสิ่งที่ LLM ดูเหมือนจะ จดจำ ได้นั้น ถูกวางลงในบริบทโดยโปรแกรมที่เรียกใช้งานมัน

ตัวเลขที่ใช้ตัดสินใจเลือกแผน VPS ของคุณคือขนาดของไฟล์นั้น เนื่องจากข้อมูลทั้งหมดต้องอยู่ในหน่วยความจำขณะที่โมเดลทำงาน สำหรับการทำ 4-bit quantisation ที่ Ollama จัดเตรียมมาให้เป็นค่าเริ่มต้น ให้คำนวณไว้ที่ประมาณ 0.6 GB ต่อหนึ่งพันล้านพารามิเตอร์ แล้วบวกเพิ่มอีกหนึ่งหรือสองกิกะไบต์สำหรับ context window และตัว runtime เอง

[
  {
    "label": "qwen3:4b",
    "download_gb": 2.5,
    "ram_gb_needed": 6
  },
  {
    "label": "qwen3:8b",
    "download_gb": 5.2,
    "ram_gb_needed": 8
  },
  {
    "label": "qwen3:14b",
    "download_gb": 9.3,
    "ram_gb_needed": 12
  },
  {
    "label": "qwen3:32b",
    "download_gb": 20.0,
    "ram_gb_needed": 24
  }
]

รุ่น qwen3:8b มีขนาด 5.2 GB บนดิสก์ และต้องการ RAM ประมาณ 8 GB เพื่อให้ทำงานได้โดยไม่เกิดการ swap VPS ขนาด 4 GB จะไม่สามารถโหลด qwen3:14b ซึ่งมีขนาด 9.3 GB ได้ แม้คุณจะยังไม่ได้พิมพ์คำใดๆ ลงไปก็ตาม รายการที่ใหญ่ที่สุดในที่นี้คือ qwen3:32b ซึ่งต้องการ RAM ประมาณ 24 GB ซึ่งในรายการราคาของส่วนใหญ่ถือเป็นแผนที่แตกต่างออกไปและมีค่าใช้จ่ายรายเดือนที่สูงขึ้น

การบรรจุลงในหน่วยความจำคือคำถามหนึ่ง ส่วนความเร็วคืออีกคำถามหนึ่ง บน VPS ที่ใช้ CPU เพียงอย่างเดียว คอขวดจะอยู่ที่ memory bandwidth มากกว่าความเร็วสัญญาณนาฬิกา ดังนั้นโมเดลที่โหลดได้อาจตอบสนองได้เพียงไม่กี่โทเค็นต่อวินาที ซึ่งเพียงพอสำหรับงานที่รันข้ามคืน แต่ไม่น่าพึงพอใจสำหรับการแชท GPU จะช่วยเพิ่มตัวเลขดังกล่าวขึ้นประมาณหนึ่งเท่าตัว และมันก็เพิ่มค่าใช้จ่ายของคุณด้วยเช่นกัน ดังนั้นควรตัดสินใจด้วยการวัดผล: ทดสอบ benchmark VPS ด้วยภาระงานที่คุณวางแผนจะรัน และอ่าน เมื่อใดที่ VPS แบบ GPU ถึงจะคุ้มค่ากับราคา หากต้องการเริ่มรันค่าน้ำหนักให้ได้จริง ให้เริ่มต้นที่ Ollama บน VPS ของคุณเอง

ผู้ช่วยคือ LLM รวมกับส่วนติดต่อผู้ใช้งานแบบแชท

ผู้ช่วยคือเลเยอร์ผลิตภัณฑ์ที่ครอบอยู่บนโมเดล ChatGPT และ Claude คือตัวอย่างของผู้ช่วย ซึ่งประกอบด้วยโมเดล หน้าต่างแชท บัญชีผู้ใช้ ประวัติการสนทนา และการจำกัดอัตราการใช้งาน เกือบทั้งหมดนี้ไม่ได้ทำงานบนฮาร์ดแวร์ที่คุณควบคุม นั่นคือเหตุผลที่ผู้ช่วยแบบ hosted ต้องเสียค่าสมัครสมาชิกและไม่กิน RAM ของคุณ

เวอร์ชันที่ self-hosted คือ front end เช่น Open WebUI ที่เชื่อมต่อกับ Ollama ในเครื่องหรือเชื่อมต่อกับ API แบบ hosted ตัว front end เป็นซอฟต์แวร์ขนาดเล็ก โดยคาดการณ์ว่าจะใช้ RAM ประมาณ 1 GB สำหรับส่วนติดต่อผู้ใช้งาน นอกเหนือจากที่โมเดลต้องการ สิ่งที่จำเป็นต้องมีซึ่งโมเดลเปล่าๆ ไม่มี คือ URL สาธารณะและใบรับรอง เนื่องจากคุณต้องการเข้าถึงจากโทรศัพท์มือถือ: ออกใบรับรองด้วย Certbot และ Nginx หรือทำ TLS termination ที่ Traefik ซึ่งวางไว้หน้าแอปพลิเคชันหลายตัว หากคุณยังอยู่ในขั้นตอนเลือก front end ให้เปรียบเทียบ ทางเลือกอื่นแทน Open WebUI

ผู้ช่วยทำหน้าที่ตอบคำถาม แต่ไม่ได้ทำหน้าที่ลงมือปฏิบัติ เมื่อผู้ช่วยเขียนคำสั่ง shell ขึ้นมา จะมีคนคอยอ่านคำสั่งนั้นและตัดสินใจว่าจะคัดลอกไปวางหรือไม่ บุคคลนั้นคือเลเยอร์ความปลอดภัย และ agent คือสิ่งที่เข้ามาแทนที่เลเยอร์ดังกล่าว

เอเจนต์เพิ่มเครื่องมือและลูปการทำงาน

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

ลูปการทำงานเป็นเพียงโค้ดทั่วไป ซึ่งลูปพื้นฐานสามารถเขียนได้ในไม่ถึงหนึ่งร้อยบรรทัด สิ่งที่ทำให้มันเป็นเอเจนต์คือการที่เครื่องมือเหล่านั้นมีข้อมูลรับรอง (credentials) จริง ทำให้ลูปสามารถเปลี่ยนแปลงสิ่งต่างๆ ภายนอกตัวมันเองได้ ข้อเท็จจริงเพียงข้อเดียวนี้เป็นตัวกำหนดการตัดสินใจในการโฮสต์ทั้งหมดที่ระบุไว้ด้านล่าง ทักษะของเอเจนต์ และ เซิร์ฟเวอร์ MCP (model context protocol) เป็นสองวิธีในการเพิ่มเครื่องมือให้เอเจนต์โดยไม่ต้องเขียนลูปใหม่

• มันมีอายุยืนยาวกว่าเซสชันของคุณ การแชทจะสิ้นสุดลงเมื่อคุณปิดแท็บ แต่การรันเอเจนต์อาจใช้เวลาถึงยี่สิบนาทีและควรทำงานต่อไปได้แม้แล็ปท็อปของคุณจะเข้าสู่โหมดพัก ดังนั้นมันจึงควรอยู่บนเครื่องที่เปิดตลอดเวลา โดยเริ่มทำงานผ่าน systemd service หรือ timer ซึ่งจะทำให้มันกลับมาทำงานใหม่หลังจากรีบูต
• มันเก็บความลับต่างๆ ไว้ ไม่ว่าจะเป็น API key, SSH key หรือรหัสผ่านฐานข้อมูล สิ่งใดก็ตามที่เอเจนต์อ่านได้ คำสั่งที่เป็นอันตรายซึ่งซ่อนอยู่ในอินพุตอาจทำให้มันนำข้อมูลเหล่านั้นไปใช้ได้ ดังนั้น จงเก็บความลับให้พ้นจากการเข้าถึงของเอเจนต์
• ค่าใช้จ่ายเพิ่มขึ้นตามลูป ไม่ใช่ตามคำถามของคุณ ทุกขั้นตอนจะส่งบทสนทนาทั้งหมดกลับไปเป็นอินพุตใหม่ ดังนั้นการรันสิบขั้นตอนจะต้องจ่ายค่าทรานสคริปต์นั้นถึงสิบครั้ง นี่คือเหตุผลว่าทำไม input tokens จึงเป็นค่าใช้จ่ายหลักของเอเจนต์ และทำไมคุณถึงควร กำหนดเพดานค่าใช้จ่ายสูงสุดต่อการรันหนึ่งครั้ง
• มันอาจทำงานผิดพลาดในลักษณะที่ส่งผลต่อการเขียนข้อมูล คำตอบที่ผิดในการแชททำให้คุณเสียเวลาอ่านใหม่ แต่การลบข้อมูลผิดพลาดภายในลูปอาจทำให้คุณเสียไดเรกทอรีไปทั้งอัน ควรเรียกใช้เอเจนต์ในฐานะ ผู้ใช้ที่มีสิทธิ์น้อยที่สุดเท่าที่ยังสามารถทำงานได้ และสำหรับเอเจนต์ที่ใช้เขียนโค้ด ควรทำแซนด์บ็อกซ์ก่อนที่จะให้สิทธิ์เข้าถึง repository ของคุณ

สิ่งที่แต่ละเลเยอร์ต้องการจากเซิร์ฟเวอร์

[
  {
    "label": "LLM (weights you host)",
    "ram_gb": 8,
    "gpu": "helps a lot",
    "public_url": "no",
    "credentials": "none"
  },
  {
    "label": "Assistant (chat surface)",
    "ram_gb": 1,
    "gpu": "no",
    "public_url": "yes",
    "credentials": "one login"
  },
  {
    "label": "Agent (tools and a loop)",
    "ram_gb": 2,
    "gpu": "no",
    "public_url": "only for webhooks",
    "credentials": "several"
  }
]

โปรดอ่านคอลัมน์ RAM อย่างละเอียด เนื่องจากตัวเลขดังกล่าวไม่รวมถึงตัวโมเดลเอง ทั้งส่วนติดต่อผู้ใช้สำหรับการแชท (chat front end) และ runtime ของเอเจนต์ต่างก็เป็นโปรแกรมขนาดเล็ก หากเอเจนต์เรียกใช้โมเดลที่โฮสต์ไว้ภายนอก RAM ขนาด 2 GB ก็เพียงพอต่อการรันโปรแกรม และการเลือกแผนบริการราคาประหยัดถือเป็นทางเลือกที่เหมาะสมมากกว่าการลดทอนประสิทธิภาพ แต่หากคุณจัดเก็บ weight ของโมเดลไว้บนเซิร์ฟเวอร์เดียวกัน ความต้องการ RAM ตามขนาดโมเดล 8 GB จะกลายเป็นปัจจัยหลักที่ส่งผลต่อทรัพยากรทั้งหมด

คอลัมน์อื่นๆ มีความสำคัญมากกว่าที่หลายคนคาดคิด มีเพียงเลเยอร์โมเดลเท่านั้นที่จะทำงานเร็วขึ้นเมื่อใช้ GPU และมีเพียงเลเยอร์ผู้ช่วย (assistant layer) เท่านั้นที่จำเป็นต้องมี URL สาธารณะเป็นปกติ เพราะเบราว์เซอร์จำเป็นต้องเข้าถึงเลเยอร์นี้ ในขณะที่เอเจนต์จะต้องการ URL สาธารณะก็ต่อเมื่อมีบริการภายนอกจำเป็นต้องเรียกเข้ามา เช่น การใช้ webhook นอกจากนี้ เอเจนต์ยังต้องจัดเก็บข้อมูลรับรอง several ซึ่งถือเป็นความแตกต่างที่สำคัญระหว่างเอเจนต์กับหน้าต่างแชททั่วไป หน้าต่างแชทอาจให้ข้อมูลที่ผิดพลาดได้ แต่เอเจนต์สามารถให้ข้อมูลที่ผิดพลาดแล้วดำเนินการตามข้อมูลนั้นได้ทันที

คุณจำเป็นต้องใช้ GPU เพื่อรัน AI agent หรือไม่

ไม่จำเป็น เว้นแต่คุณจะโฮสต์ weight ของโมเดลไว้บนเครื่องเดียวกันด้วย ลูปการทำงานของ agent ประกอบด้วยการส่ง HTTP request, การประมวลผล JSON และการเรียก subprocess ซึ่ง CPU จะแทบไม่ได้ทำงานในขณะที่รอการตอบสนองจากเครือข่าย ดังนั้นคำถามเรื่อง GPU จึงเป็นเรื่องของเลเยอร์ LLM โดยเฉพาะ

ดังนั้นให้แยกการตัดสินใจออกเป็นสองส่วน หากข้อมูลข้อความไม่สามารถออกจากเครื่องของคุณได้ ให้ลงทุนกับหน่วยความจำเพื่อโหลดโมเดล และลงทุนกับ GPU เพื่อให้ได้ความเร็วที่ใช้งานได้จริง แต่หากคุณต้องการเพียงระบบอัตโนมัติ ให้เช่าใช้โมเดลแบบจ่ายตามการใช้งาน (per token) แล้วนำงบประมาณไปลงทุนกับ uptime และการสำรองข้อมูลแทน ในปี 2026 agent ส่วนใหญ่ที่โฮสต์เองจะเรียกใช้งานโมเดลผ่านบริการภายนอก ซึ่งช่วยให้ประหยัดค่าใช้จ่ายในการรันระบบมากกว่า

คุณสามารถ self-host AI agent ได้หรือไม่

ได้ และ agent คือเลเยอร์ที่คุ้มค่าที่สุดในการ self-host เพราะเป็นส่วนที่ข้อมูลและ credential ของคุณทำงานอยู่ VPS ขนาดเล็กที่มี RAM 2 GB, service manager และการเข้าถึงเครือข่ายขาออกสามารถรัน agent จริงได้ ให้เลือก เส้นทางการสร้างด้วยตนเองบน VPS หากคุณต้องการควบคุมลูปการทำงานด้วยตนเอง หรือ ปรับใช้ agent สำเร็จรูปที่รองรับการ self-host หากคุณต้องการเริ่มต้นจากสิ่งที่พร้อมใช้งานแล้ว

การ self-host ผู้ช่วยนั้นทำได้ง่าย โดยเป็นเพียง container หนึ่งตัวและ certificate หนึ่งใบ ส่วนการ self-host โมเดลนั้นเป็นส่วนที่มีค่าใช้จ่ายสูง และเป็นสิ่งที่ผู้คนมักเลิกทำหลังจากเห็น token ค่อยๆ ประมวลผลออกมาจาก CPU อย่างช้าๆ ให้ทำการ self-host weights เมื่อข้อมูลไม่สามารถออกจากเครื่องได้ หรือเมื่อปริมาณการใช้งานของคุณทำให้ราคาต่อ token สูงเกินไป มิฉะนั้น ให้ปล่อยให้ agent เรียกใช้ API และเก็บส่วนที่สำคัญไว้ในเครื่องของคุณเอง

ChatGPT เป็น AI agent หรือไม่

ผลิตภัณฑ์แชทจะกลายเป็น agent ทันทีที่สามารถเรียกใช้เครื่องมือและดำเนินการตามผลลัพธ์นั้นได้โดยไม่ต้องรอการยืนยันจากคุณ หากใช้เกณฑ์นี้ ผู้ช่วยที่โฮสต์อยู่บนระบบคลาวด์ซึ่งมีความสามารถในการสืบค้นข้อมูล เรียกใช้โค้ด หรือเชื่อมต่อกับบริการอื่นถือเป็น agent ทั้งสิ้น ความแตกต่างสำหรับคุณคือวงจรการทำงาน (loop) นั้นรันอยู่ที่ใดและใช้ข้อมูลรับรอง (credentials) ของใคร ในผลิตภัณฑ์ที่โฮสต์โดยผู้ให้บริการ ทั้งสองส่วนนี้เป็นของผู้ให้บริการ แต่หากรันบนเซิร์ฟเวอร์ของคุณเอง ทั้งสองส่วนจะเป็นของคุณ รวมถึงความรับผิดชอบต่อการกระทำใดๆ ที่วงจรนั้นดำเนินการในช่วงเวลาตี 3 ด้วย

การตอบสนอง การวางแผน และระบบหลายเอเจนต์ (Multi-agent)

บทสรุปส่วนใหญ่มักระบุประเภทของเอเจนต์ไว้ 7 ประเภท ซึ่งส่วนใหญ่เป็นเพียงคำโฆษณาทางการตลาด มีเพียงสองความแตกต่างที่ส่งผลต่อโค้ดที่คุณเขียน และอีกหนึ่งความแตกต่างที่ส่งผลต่อค่าใช้จ่าย เอเจนต์แบบตอบสนอง (Reactive agent) จะเรียกใช้เครื่องมือ อ่านคำตอบ และตอบกลับ ส่วนเอเจนต์แบบวางแผน (Planning agent) จะเขียนแผนงานก่อนแล้วจึงดำเนินการตามแผน ซึ่งให้ผลลัพธ์ที่ดีกว่าในงานระยะยาว แต่มีค่าใช้จ่ายเป็นโทเค็นสูงกว่าเนื่องจากแผนงานจะถูกส่งซ้ำในทุกขั้นตอน สำหรับระบบหลายเอเจนต์ (Multi-agent) จะช่วยให้เอเจนต์หนึ่งสามารถสั่งเริ่มเอเจนต์อื่นได้ ซึ่งจะเพิ่มทั้งการใช้โทเค็นและโอกาสที่จะเกิดความล้มเหลวไปพร้อมกัน ดังนั้นจึงคุ้มค่าก็ต่อเมื่องานย่อยมีความเป็นอิสระต่อกันอย่างแท้จริง เช่น การค้นหาจาก 4 แหล่งข้อมูลพร้อมกัน ให้เริ่มต้นจากแบบตอบสนอง เพิ่มการวางแผนเมื่อการทำงานเริ่มยาวนานขึ้น และใช้ระบบหลายเอเจนต์เป็นลำดับสุดท้าย สำหรับภาพรวมที่กว้างขึ้น โปรดดู สิ่งที่ควรเรียนรู้เกี่ยวกับ AI agents ในปี 2026

วิธีตรวจสอบว่าคุณกำลังรันโมเดลในเลเยอร์ใด

บนเซิร์ฟเวอร์ ให้ตรวจสอบว่าโพรเซสใดเป็นผู้ใช้หน่วยความจำ

free -h
ps -eo rss,comm --sort=-rss | head -5

หากบรรทัดบนสุดคือ ollama หรือ llama-server ซึ่งมีการใช้ RSS (Resident Set Size หรือหน่วยความจำที่โพรเซสใช้งานจริง) หลายกิกะไบต์ แสดงว่าคุณกำลังโฮสต์โมเดลด้วยตนเอง หากไม่มีโพรเซสใดใช้หน่วยความจำเกินสองสามร้อยเมกะไบต์ แต่ค่าใช้จ่าย API ของคุณยังคงเพิ่มขึ้นเรื่อยๆ แสดงว่าคุณกำลังโฮสต์เอเจนต์หรือผู้ช่วยและเช่าใช้งานโมเดลอยู่ หากรายการดังกล่าวว่างเปล่าเนื่องจากทุกอย่างทำงานอยู่บนแท็บเบราว์เซอร์ แสดงว่าคุณเป็นเพียงผู้ใช้งานผู้ช่วย ซึ่งเป็นสถานะที่เหมาะสมจนกว่าคุณจะต้องการซอฟต์แวร์ที่สามารถดำเนินการแทนคุณได้

คุณต้องการรันตัวเลือกใด

• หากต้องการเก็บข้อมูลให้เป็นส่วนตัว ให้รันโมเดลโดยดูที่: การ self-host LLM ด้วย Ollama จากนั้นเปรียบเทียบระยะเวลาการทำงานด้วย Ollama เทียบกับ vLLM เมื่อมีผู้ใช้งานเพิ่มขึ้นจากหนึ่งเป็นสิบคน
• หากต้องการควบคุมลูปการทำงานและเครื่องมือต่างๆ ด้วยตนเอง ให้สร้างเอเจนต์โดยดูที่: การสร้าง AI agent ของคุณเองบน VPS
• หากต้องการให้ระบบใช้งานได้จริงภายในเย็นนี้ ให้ติดตั้งระบบที่เสร็จสมบูรณ์จาก: เอเจนต์แบบ self-hosted ที่น่าใช้งาน
• หากคุณยังไม่มีเซิร์ฟเวอร์สำหรับรันงานเหล่านี้ ให้เริ่มต้นที่: สิ่งที่คุณจะได้รับจาก VPS จริงๆ

FAQ

AI agent เป็นเพียง LLM ที่เพิ่มขั้นตอนพิเศษเข้าไปใช่หรือไม่?

ขั้นตอนพิเศษเหล่านั้นคือตัวผลิตภัณฑ์ LLM ทำหน้าที่แปลงข้อความเป็นข้อความเท่านั้น แต่ agent จะล้อมรอบ LLM ด้วยเครื่องมือที่เรียกใช้ได้และลูปที่คอยเรียกเครื่องมือเหล่านั้นซ้ำๆ เครื่องมือเหล่านี้มีข้อมูลรับรอง (credentials) อยู่ด้วย ทำให้ผลลัพธ์สามารถเปลี่ยนแปลงไฟล์ ฐานข้อมูล หรือบริการที่กำลังทำงานอยู่ได้ นี่คือเหตุผลที่ agent จำเป็นต้องมีเครื่องที่เปิดทิ้งไว้ตลอดเวลา, service manager และนโยบายการจัดการความลับ (secrets policy) ในขณะที่ LLM ต้องการเพียงหน่วยความจำที่เพียงพอสำหรับเก็บค่า weight ในระหว่างการตอบคำถามเท่านั้น

ฉันจำเป็นต้องใช้ GPU เพื่อรัน AI agent หรือไม่?

ไม่จำเป็นสำหรับตัว agent เอง ลูปการทำงานประกอบด้วย HTTP requests, การจัดการ JSON และการเรียก subprocess ซึ่ง CPU ทั่วไปสามารถจัดการได้ในขณะที่รอการตอบสนองจากเครือข่าย คุณจะต้องการ GPU ก็ต่อเมื่อคุณโฮสต์ model weights ด้วยตนเองและต้องการความเร็วในการประมวลผลมากกว่าสองสามโทเค็นต่อวินาที agent ที่เรียกใช้โมเดลผ่าน API สามารถรันบน VPS ขนาดเล็กที่ไม่มี GPU ได้อย่างราบรื่น

VPS ต้องการ RAM เท่าใดสำหรับ AI agent?

ประมาณ 2 GB เมื่อ agent เรียกใช้โมเดลผ่าน API เนื่องจาก runtime, dependencies และฐานข้อมูลขนาดเล็กในเครื่องคือสิ่งที่ต้องใช้หน่วยความจำทั้งหมด หากคุณโฮสต์โมเดลเองให้บวกเพิ่มเข้าไป โดย qwen3:8b เพียงอย่างเดียวต้องการ RAM ประมาณ 8 GB ดังนั้นเครื่องแบบ all-in-one จะเริ่มต้นที่ระดับนั้นและเพิ่มขึ้นตามขนาดของโมเดลที่คุณเลือก

ฉันสามารถโฮสต์ AI assistant ด้วยตนเองเพื่อรักษาความเป็นส่วนตัวของบทสนทนาได้หรือไม่?

ได้ แต่มีข้อควรระวังประการหนึ่งที่เป็นตัวตัดสินทุกอย่าง front end ที่โฮสต์เองอย่าง Open WebUI จะเก็บข้อมูลบัญชีและประวัติไว้บนเซิร์ฟเวอร์ของคุณ แต่บทสนทนาจะยังคงเป็นส่วนตัวก็ต่อเมื่อโมเดลที่อยู่เบื้องหลังนั้นรันอยู่ในเครื่องด้วยเช่นกัน หากคุณตั้งค่าให้ front end เดียวกันนี้ชี้ไปยัง API ที่โฮสต์ไว้ภายนอก ข้อความก็จะถูกส่งออกจากเครื่องของคุณในทุกข้อความ ดังนั้นคุณจะเก็บได้เพียงประวัติ แต่ไม่ใช่ความเป็นส่วนตัว

AI agent กับ chatbot แตกต่างกันอย่างไร?

chatbot จะตอบกลับแล้วหยุดทำงาน แต่ agent จะตัดสินใจว่าจะทำอะไรต่อไป เรียกใช้เครื่องมือ อ่านผลลัพธ์ และตัดสินใจอีกครั้งจนกว่างานจะเสร็จสิ้นหรือถึงขีดจำกัดที่กำหนดไว้ บททดสอบในทางปฏิบัติคือ หากซอฟต์แวร์สามารถเปลี่ยนแปลงสิ่งใดสิ่งหนึ่งได้โดยไม่ต้องมีมนุษย์กดปุ่มระหว่างการตอบสนองและการดำเนินการ นั่นคือ agent และมันจำเป็นต้องมีการโฮสต์รวมถึงมาตรการป้องกัน (guardrails) ที่มาพร้อมกับการโฮสต์นั้น