🎞️ Videos → Engineering OpenClaw: Scalable, Safe, and Cost-Optimized Agents

เริ่มต้น: ภาพรวมวิศวกรรม OpenClaw และเทคนิคการเพิ่มประสิทธิภาพ0:00

มาพูดถึงเรื่องการ engineering ของ OpenClaw นะครับ เมื่อกี้เราดูไปแล้วว่า OpenClaw คืออะไร ใช้งานยังไง จากพี่เอ๋อ และก็ดูว่าเราจะ secure มันยังไง วันนี้จะมา deep dive กันดูครับว่า

architecture มันคืออะไร เราจะ fine tune หรือว่าทำให้มันมี efficiency มากขึ้นยังไง รวมถึงถ้าเราจะ connect กับ local model เราจะต้องทำยังไงบ้าง และสุดท้ายก็จะเป็นเรื่องการ red teaming เมื่อกี้เราดูด้าน secure ละ มาดูด้าน attack บ้างว่าเราจะ attack เทคนิคในการ attack ตัว OpenClaw นี่มันมีอะไรบ้างครับ เดี๋ยวเริ่มเลยครับ สวัสดีครับ ผมเปรม

โอเค อันนี้จะสามารถใช้ตัวคอมผมได้ไหม พอดีมีโค้ด หรือว่าถ้าเกิดไม่ได้

พูดเลย พูดเลย โอเค จริงๆ ผมมีโค้ดเอาไว้ แต่ว่าผมกลัวว่าถ้าเกิดไปต่อ HDMI ของผมเนี่ย ผมกลัวว่าไอ้ฝั่งนี้จะหลุด เมื่อกี้เรา struggle กันมากเลยนะครับ

ผมขอถามทุกคนในห้องนี้ก่อนว่า ในห้องนี้นอกจากคนที่ใช้ OpenClaw แล้ว มีใครที่ใช้พวก Nanobot ไหมฮะ

Besides OpenClaw, does anybody in here also use Nanobot? Anyone? Or maybe like ZeroClaw?

Wow, this guy tries everything.

แป๊บนึงครับ

คือ ลอง OpenClaw แล้วไม่ค่อยชอบครับ เพราะว่ามันกิน resource เยอะ ก็เลยเลิกเลี้ยงกุ้งตอนนั้นไป แล้วก็ไปเลี้ยงกุ้งฝอย เลี้ยงกุ้งอะไรอย่างนี้แทน

วิวัฒนาการของตระกูล Claw: จาก Nanobot สู่ NullClaw เพื่อการประหยัดทรัพยากร1:34

มันเป็น point เลยนะว่าเวลาที่เรามาใช้ตัว OpenClaw อย่างเงี้ย เดี๋ยวถามทุกคนก่อนว่า สงสัยกันไหมว่าทำไมตัวของตระกูลพวกเนี้ยมันออกมาเยอะเหลือเกิน จริงๆ ผมอยากจะเล่าเงี้ยว่า feature ถ้าเกิดเราไปส่องของมันจริงๆ ก็เหมือนที่พี่เอ๋อได้บอกไว้ข้างต้นนะครับ จริงๆ ผมไม่มี slide ผมด้นสดเลยนะครับ ก็ผมบอกก่อนว่าตัว feature เนี่ย มันไม่ได้มีอะไรเยอะมาก คือเรามี gateway ตัวนึง เป็น long running task ที่ทำให้ตัว Claw ของเราเนี่ย มันรันได้ไปเรื่อยๆ โดยที่ไม่มีวันหยุด แล้วก็จะมีเรื่องของการ connect to channel นะครับ ด้วยเหตุนี้เนี่ย มันก็เลยมีพวก เพราะว่าตัว core feature เนี่ย มันมีไม่เยอะมาก ก็เลยมี version ต่างๆ ออกมามากมายนะครับ หนึ่งสิ่งที่จะเกิดขึ้นก็คือ มันแข่งกันเล็ก แข่งกันเล็ก ก็คือตั้งแต่เรามี Nanobot ของ Python ที่มาตัด feature ที่จำเป็นออกไป จนมาถึงเรื่องของตัว ZeroClaw ที่ใช้ตัวของ Rust

ในการเขียน เพื่อลดเรื่องของ memory ออกไป จนล่าสุดมีตัวของ NullClaw ที่ใช้ตัวของ Zig ในการเขียน ซึ่งเขา claim ว่ามันเล็กมากๆ จนแบบ เล็กเหี้ยๆ เลยครับผม

I'll give you a quick translation because I think there's something interesting. So what he was talking about was asking this gentleman why he was using Nanobot and these other tools. And he said because taking care of that giant crab was eating too much of my resources, so I switched to tiny shrimp to replace that. And he said, well, yeah, actually these models can, these particular installations can actually waste your resources in a very damaging way. The direct translation is "Hear hear."

โอเค ใช่

ขอบคุณมาก thank you for translation. และขอถามคุณพี่คนนี้หน่อยได้ไหมครับว่า ตอนที่เราใช้ ZeroClaw เนี่ย เราเจอปัญหาอะไรบ้างไหม? ปัญหาก็คือ จริงๆ ผมเคยเขียนเล่าในกลุ่มไปแล้วนะฮะ ก็คือ มันไม่สามารถแบ่ง section ได้เหมือน OpenClaw อ่า ใช่ ใช่เลยครับผม หนึ่งสิ่งที่เรารอเจอกัน ระหว่างตัวของพวก Claw ที่มันเป็นตระกูลที่มันเล็กกว่า ตัว OpenClaw เนี่ย ก็คือว่า มันมี feature ที่มันไม่ทันตัวของ OpenClaw นะครับ สิ่งนี้ผมเจอมาเหมือนกัน เพราะว่าผมใช้ตัวของ Nanobot ที่เขียนด้วย Python เหตุผลที่เลือกเป็น Nanobot เนี่ย เพราะว่าผม ค่อนข้าง familiar กับตัว Python นะ แล้วทีนี้เนี่ย มันเป็นจุดเริ่มต้นที่ทำให้ผม จะต้องไปศึกษาว่าข้างในของมันมีอะไรบ้างนะครับ

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

คือ ตัวโค้ดเนี่ย ถ้าเกิดว่าทุกคนได้มีโอกาสได้ลองไปดูนะ เราจะเห็น pattern ที่มันเหมือนกันมาก มันมีตัวของ agent มันมีตัวของ provider นะครับผม แล้วทีนี้เนี่ย หลักการทำงาน ไม่ต่างกันเลยนะครับผม

เบื้องหลังการทำงานของ Agent: การทำ Orchestration ด้วย ReAct Prompting4:19

ยิ่งในส่วนของการทำ agent orchestration เออ ผมลืมบอกไปนะ ตำแหน่งของผมเนี่ยเป็น AI Engineer ผมสนใจว่าวิธีการที่ตัวของ AI หรือว่าพวก LLM มันถูก routing เป็น application ที่ดีได้สักตัวหนึ่งเนี่ย มันมีการ orchestration ยังไงบ้างนะครับ ซึ่งพอผมได้ไปส่องอะ ผมก็มีสมมติฐานอันนึงว่า ตัวของ OpenClaw เนี่ย เขาไม่ได้มีเทคนิคในการ routing หรือ orchestration ที่มัน advanced กว่า application ทั่วไปนะครับ ก็คือการใช้ตัวของ ReAct prompting ผมขออนุญาตเถอะ ผมอยากเปิดภาพนี้จริงๆ

เดี๋ยวผมจะซูมให้ดูเลยนะครับ โอเค sure

ผมบอกนิดนึงนะ ถ้าเกิดว่าคุณมองไม่เห็น คุณลงทะเบียนวันที่ 11 มีนาคมนะครับ มีงาน Claude Code อยู่ ผมไปพูดด้วย แต่ขิงเสร็จแล้วเนี่ย ผมอยากจะเล่าตรงนี้ว่า ReAct prompting เนี่ย เห็นกันไหมครับ?

โอเค sure ก็คือว่า feeling ของมันเนี่ย ก็คือว่า เขาจะรับคำถามของ user ไป แล้วมาแปลงว่า เฮ้ย เขาสามารถตอบคำถามของ user หรือว่าทำ action อะไรบางอย่างได้ด้วยตัวมันเองได้หรือเปล่า ถ้าเกิดว่ามันทำไม่ได้ สิ่งหนึ่งที่เขาจะทำก็คือว่า เขาจะไปเลือก action หรือ skill ที่มัน available อยู่ แล้วให้ตัว runtime ไม่ว่าจะเป็น Node.js runtime หรือเป็น Python runtime เนี่ย ช่วยในการ execute ให้ครับ ส่วน output เนี่ย มันจะถูกแปลงเป็น context loop back กลับมาอย่างนี้ ถ้าเกิดไป search ใน code เนี่ย มันจะชื่อว่า agent loop นะครับ อยากให้ทุกคนได้ search ดูนะครับ ก็จะมี pattern ประมาณนี้

Can you see it? I can see it. I don't think they can. Okay, sure. How do agents select actions? He's talking about ReAct prompting, reasoning plus the acting loop. และ AI มันใช้ tool ได้ยังไง?

And so it just explains how it uses tools. Did he say that how the AI can use tools? That's all. You don't need my help, you can just explain it in English. Exactly. และก็ ใช่ นะครับผม ก็คือว่า

ถ้าเกิด ผมถึงไหนแล้วเมื่อกี้เนี้ย ก็คือว่า ตัวของ OpenClaw เนี่ย มันมี structure ข้างในอยู่ที่ประมาณนี้ นะครับผม และสิ่งหนึ่งที่จะทำให้ไอ้พวกนี้มันต่างกันได้ 1 คือ มันมีเรื่องของการทำเรื่องของ planning นะครับ ว่า ใน step ในการเลือก action เนี่ย มันจะเลือกอันไหนก่อน หรืออันไหนหลัง นะครับ และสิ่งที่สำคัญอีกอย่างหนึ่ง ก็คือตัวของ LLM หรือตัว model นั่นเอง นะครับ ถ้าคุณเลือกเป็น Anthropic Claude อย่างเงี้ย มันก็จะเลือก action ได้ตรงกับความต้องการของคุณอยู่ นะครับ สมมติว่าอยากจะ อยากให้มันแบบ

ไป execute พวกตลาดหุ้น อย่างเงี้ย มันก็จะ execute skill ที่มัน available ได้ตรงกับสิ่งที่คุณต้องการ นะครับผม แล้วทีนี้เนี่ย มันจะมีปัญหาอีกปัญหาหนึ่ง

ก็คือว่า เวลาเราเลือก Large Language Model ใช่ไหมฮะ มันก็จะ มีเรื่องของ token ที่มันต้องใช้ นะครับ บางอันใช้แล้วมันแพง ซึ่งวันนี้เนี่ย เรามี expert มา 3 ท่านเลย นะครับ 4 ท่าน รวมผมด้วยนี่หว่า นะครับ

ก็ จะมี Job นะครับ ที่เขาจะถนัด เรื่องของการ hosting เรื่อง model local model มาก แต่ว่าวันนี้เขาจะพูดเรื่องของ Qwen นะครับ และก็มีอาจารย์มีน ที่เก่งเรื่อง token optimization และก็มีพี่แบงค์ นะครับผม เดี๋ยวจะมาเล่าเรื่องของ security ด้วย การทำ red teaming ว่ามันทำยังไงนะ เดี๋ยวขอส่งไมค์ให้ Job ก่อนนะครับ

การติดตั้ง Local Model: แนะนำ vLLM และโมเดล Qwen ที่เก่งภาษาไทย7:42

ครับ โอเคครับ ขอบคุณเปรมมากเนาะ เมื่อกี้เปรมเล่าก็จะเห็นเรื่อง overall architecture เนาะ พวก ReAct prompting อะไรพวกนี้เนาะ ถ้าเป็นสาย developer ด้าน AI Engineer น่าจะรู้จักกัน เพราะว่าทำ agent กันประจำอยู่เนาะ ส่วนผมจะพูดเรื่อง localization นะครับ ก็คือถ้ามีท่านไหนเสริม พูดได้นะ

เรื่อง localization เพราะว่าสิ่งที่สำคัญคืออะไร เมื่อกี้เราฟังเรื่อง security มาแล้ว เราจะมั่นใจได้ยังไงว่า เราใช้ API เนี่ย มันจะปลอดภัย

ผมก็จะเน้นเรื่องว่า ทำไมเราไม่ใช้พวก local model เราสามารถปรับ config อะไรได้เยอะเนาะ แล้ววิธีการ deploy local model best practice อะ ผมก็จะแนะนำ framework ตัวหนึ่ง ชื่อว่า vLLM นะครับ แล้วก็มีใครรู้จัก vLLM บ้าง? โอ้ เยอะเลย You're familiar with vLLM? vLLM? Yeah. โอเค ประมาณ 99% โอเค ไม่ใช่ ประมาณ 9% ไม่ใช่ 90 ใช่ไหมครับ? 99%... 9%... 9% of the room. So what is vLLM ครับ? vLLM ก็คือเป็น ถ้าทุกคนอาจจะรู้จัก Ollama อยู่แล้วนะ ที่จริงมันเป็นตัว AI inference เหมือนกัน แต่ตัว vLLM มันสามารถ optimize ได้เยอะ ถ้ารู้จัก keyword หนึ่งชื่อว่า KV cache การทำพวก caching หรือปกติเวลาเรา input คำสั่งไปให้ตัว open call เนี่ย มันจะมีหนึ่งที่เรียกว่า first token ที่มัน release ออกมา มันจะช้านะครับ เพราะว่า agent มันไปทำนู่นนี่นั่น แต่ว่าตัวนี้มันทำ memory caching ไว้ แล้วสามารถรู้ได้ว่าโอเค state มันเป็นอะไร คือมันช่วยในการ manage พวก caching พวก memory ได้ดีมาก อีกตัวหนึ่งที่ผมโชว์เนาะ คือตัว Qwen model ซึ่งมันเป็นตัวที่ดีมากๆ เลย ผมแนะนำนะครับ เพราะว่าอะไร เพราะว่า 1 คือ มันเขียนภาษาไทยแม่นมาก 2 คือ มันตัวเล็กมาก มันมีขนาดตัวเล็กมากๆ ถึงแบบ 0.8 หรือว่าล่าสุดที่มี 9 billion ที่บอกว่าชนะ GPT-4o 120 billion 9 billion ชนะ 120 โห แบบ สุดยอดมากเลย ใช่ไหมครับ? อีกอย่างหนึ่งคือ เราสามารถทำ quantization ให้มันเล็กลงได้อีก

ถ้าเพื่อนๆ รู้จัก ถ้าเป็น AI Engineer จะมีวิธีชื่อว่า LoRA หรือว่า QLoRA ที่สามารถ quantization model ให้ขนาดเล็กอยู่แล้ว เล็กกว่าได้อีก มันจะมี tool หนึ่งชื่อว่า Unsloth AI มีใครรู้จัก Unsloth AI ไหมครับ? Unsloth AI? Unsloth AI ก็เป็น quantization model Qwen ให้มันลดลงไปอีก อย่างเช่น 0.82 billion

ผมไปอ่านมา เขาบอกว่าสามารถรันผ่าน mobile ได้ mobile device ได้ มันก็โอ้ crazy มาก ใช่ไหมครับ? อีกตัวหนึ่งก็คือ 9 billion ที่เขาใช้กันอยู่เยอะๆ ก็คือว่าเป็น model ใหม่ที่ออกมา แล้วชนะ 120 billion ก็ดี ก็คือผมใช้ vLLM ผสมกับตัว Unsloth นะครับ

ทำให้ model มันเก่งมาก รันใน local model ได้ ไม่ต้องมี GPU เยอะ

การรันโมเดลโดยไม่ต้องพึ่งการ์ดจอแรง: เทคนิคการผสม VRAM, RAM และ SSD10:12

อีกอย่างหนึ่งคือ ถ้าเราใช้ model ที่ชื่อว่า GGUF เป็น format ใช่ไหมครับ เราสามารถ... บางคนอาจจะคิดว่าใช้ GPU อย่างเดียวรันไหม ไม่จำเป็นนะครับ เราสามารถใช้ GPU ผสม RAM ในเครื่องได้ ผสม mix กันนะครับ หรือว่า ถ้าไม่มี โห RAM มันแพง ทำไงดี ผมสามารถใช้ SSD ได้ แต่ว่ามันจะช้านิดนึง เราสามารถใช้ VRAM, RAM แล้วก็ SSD นะครับ

ในการผสมให้มันสามารถรัน model ขนาดเล็กขนาดใหญ่ได้ แปลว่า เพื่อนๆ ไม่ต้องบอกว่า โอ้ย ผมไม่มีสเปกแรงๆ ผมทำไม่ได้ ไม่มีปัญหา ถ้าเราใช้ vLLM ผสมกับ Unsloth model ก็สามารถรัน model Qwen ได้ใน local ได้ So if you use vLLM plus Unsloth, you can actually run the Qwen models locally successfully without having a high spec of hardware, correct? Yeah. คุณ Job you speak Thai so fast, I have to แบบ ตั้งใจฟัง พูดเร็วมากครับ

ที่จริงก็ประมาณนี้เนาะ หลักการ localization ก็คือว่า ที่จริงไม่จำเป็นต้องเป็น Qwen มี MiniMax หรือ GLM หรือว่าเป็น whatever ที่ทุกคนชอบนะครับ สามารถเอามาลงบนเครื่องได้ แล้วก็ลองใช้งานกันได้ ผมก็จะแนะนำตรงนี้ เป็นตัวของ Qwen ส่งต่อให้อาจารย์มีน อาจารย์...

โอเคครับ

Token Optimization: เปรียบเทียบค่าใช้จ่ายภาษาไทยและเทคนิคประหยัด Token11:27

เดี๋ยวของผมต่อครับ ก็เรื่องมันใกล้ๆ กันครับ ของผมเป็นเรื่องตัว token optimization นะครับ เดี๋ยวใครเสริมได้ เสริมได้เลยนะครับ จริงๆ แล้วเรื่อง token optimization ครับ จริงๆ มันมีหลายเทคนิคครับ แต่เดี๋ยววันนี้จะเอามาเล่าสัก 7 อันแล้วกัน ที่เป็น 7 อันหลักๆ อันแรกนะครับ เดี๋ยวสไลด์เดี๋ยวผมแจกนะครับ ไม่ต้องกังวล อันแรกเรื่องภาษาครับ เราต้องเข้าใจตรงกันก่อนนะครับ ว่าพวก LLM เหล่านี้ มันไม่ได้มองคำศัพท์ต่างๆ ประโยคต่างๆ เนี่ย ไม่ได้มองเป็นคำ มันจะมองเป็นหน่วยพิเศษอันหนึ่งที่มันเรียกว่า token นะครับ ซึ่ง token มีวิธีการนับที่แตกต่างกันแล้วแต่ภาษา ภาษาไทย ภาษาอังกฤษ เนี่ย อาจจะนับไม่เหมือนกัน อันนี้เป็นตัวอย่างแล้วกันนะครับ ของคำว่า strawberry strawberry เนี่ย มี 10 ตัวอักษรครับ แต่ถ้าเป็น GPT-5.x

มันจะคำนวณแล้วเป็น 3 token นะครับ

ทีนี้ประเด็นคือมันน่าสนใจยังไง ก็คือว่าเรามาดูต่อว่า แล้วถ้าเป็นภาษาอย่างเช่น ระหว่างภาษาไทยกับภาษาอังกฤษล่ะ สมมติว่าคำว่า hamburger นะ มี 9 ตัวอักษรครับ แต่นับ 2 token แต่ในขณะที่เราใช้ภาษาไทยเนาะ ถ้าเราใช้ภาษาไทย ในการคุยกับตัว OpenClaw หรือแม้กระทั่งใช้กับตัว LLM ตัวอื่น ภาษาไทยจะเปลือง token สูงกว่า เห็นไหมครับ? คำว่า สวัสดี เนี่ย มี 6 ตัวอักษรเอง แต่กิน token ตั้ง 4 token แปลว่าคำว่า สวัสดี เนี่ย เปลืองการประมวลผลมากกว่า ทั้งขาเข้าและขาออกนะครับ ซึ่งถ้าเท่าที่เราเข้าใจกันเนาะ ตัว OpenClaw เนี่ย เราใช้ ถ้าเราใช้ API

มันก็มีค่าใช้จ่ายตามตัว token ถูกไหม? ดังนั้นถ้าเราใช้ prompt เป็นภาษาไทย ไม่ว่าจะเป็น system prompt หรืออะไรก็ตามเป็นภาษาไทย มันยิ่งกิน token สูงขึ้นเรื่อยๆ นะครับ ทีนี้ผมลองเป็นประโยคยาวๆ ครับ อันนี้เป็นเรื่องกระต่ายกับเต่าแบบประโยคเดียวเลยครับ ผมเทียบกันระหว่างภาษาอังกฤษ ภาษาจีน ภาษาไทย ภาษาอะไรนะ ทมิฬ

แล้วก็อันสุดท้ายเป็น Amharic อะไรเงี้ยครับ จะสังเกตว่าภาษาอังกฤษเนี่ย ทั้งประโยคเนี่ย กิน 31 token แต่พอเป็นภาษาจีนก็จะเพิ่มสูงขึ้นเป็น 38 token จะสังเกตว่าภาษาจีนเนี่ยมันเป็นคำๆ เลยเนาะ ภาษาไทยเนี่ยแทบจะไม่มีช่องว่างเนาะ เป็นติดกันหมด แต่มันกินไป 46 token ทีนี้ดูความเปลืองนะ ก็คือภาษาจีนเนี่ย มันมากกว่าภาษาอังกฤษ 1.2 เท่า ภาษาไทยมากกว่า 1.5 เท่า ภาษาทมิฬ 57 token มากกว่า 1.8 เท่า

ส่วนภาษาอันสุดท้ายเนี่ย 183 token มากกว่าประมาณเกือบ 6 เท่า For the English speakers in the room, this is exactly the same sentence in all the different languages and how it's different in terms of its token usage. Yes right. โอเค แต่จริงๆ แล้ว อันนี้แค่ประโยคนี้ครับ แต่จริงๆ แล้ว ถ้าคุณใช้ภาษาไทยนะ มันจะเปลืองมากกว่า

เฉลี่ยประมาณ 2.5 เท่า เมื่อเทียบกับภาษาอังกฤษ ดังนั้น ณ วันนี้ ถ้าเราคุยภาษาอังกฤษได้ ผมแนะนำว่า คุยภาษาอังกฤษ ตัวค่า token มันจะถูกกว่านะครับ

ทีนี้ ส่วนที่สอง นะครับ เสริมไหมครับ อยากจะเสริมนิดหนึ่งนะครับว่า ในการทำพวก background สมมติว่าเราต้องการใช้ภาษาไทยจริงๆ แต่ว่าในการ routing หรือว่าการทำ agent orchestrate ให้มันทำงานข้างหลังบ้านเนี่ย เราอาจจะมี agent ตัวหนึ่ง ในการช่วยแปล จากภาษา whatever เป็นภาษาไทย ภาษาญี่ปุ่น ให้เป็นภาษาอังกฤษ ที่อยู่ที่ back end ของเรา และให้มันไป process พวก task อะไรต่างๆ จะมีเรื่องของความที่มัน 1 ประหยัด token ด้วย และโอกาสที่จะตอบถูก ก็จะมีมากกว่าด้วยนั่นเองครับ และในขาที่เป็น output เนี่ย เราอาจจะมี agent อีกตัวหนึ่ง ในการแปลกลับไป เป็นภาษาต้นทางอย่างภาษาไทย ก็จะเป็นอีกหนึ่งเทคนิคครับ ครับ ทีนี้ เทคนิคที่สองนะครับ ก็คือตอนที่เราตั้ง system prompt นะครับ จริงๆ เทคนิคนี้ ผมเอามาจากตัวนายคนนี้ครับ ที่ชื่อว่า Scale Up Media ครับ เขาทำเป็นสไลด์ไว้อยู่แล้วว่า เราควรจะ optimize ตัว token ยังไงบ้าง จริงๆ เข้าไปดูในตรงนี้ครับ มีหลายเทคนิคเลยที่เขาใส่ไว้ ผมหยิบยกมาบางส่วนนะครับ อันแรกคือเราควรจะมาตั้งใน system prompt นะครับ ว่าเราควรจะโหลดแค่เฉพาะสิ่งที่จำเป็น อะไรไม่ควรโหลด และบางจังหวะทำอะไรไม่ทำอะไร การตั้งแค่นี้เขาเขียนว่า สามารถเซฟได้ประมาณ 80% ของ context ที่จะ overhead แค่เราตั้งตัวนี้ไปแทนนะครับ

อันนี้คือเทคนิคที่สองนะครับ ซึ่งพวกนี้มันจะโหลดแบบบ่อยใช่ไหมครับ ตัวที่สองนี้จะค่อนข้างมีความสำคัญนะครับ

Model Routing: การสลับใช้โมเดลเล็กและใหญ่ตามความยากของงาน15:53

อันที่สามนะครับ เรื่อง model routing นะครับ อันนี้มีความสำคัญมากครับ ก็คือ เราควรมาตั้งครับว่า อะไรเป็นโมเดลหลัก อะไรเป็นโมเดลรอง เราสามารถตั้งไว้ในตัว OpenClaw อย่างเช่น ที่เขาแนะนำนะ สมมติว่าผมเป็น จริงๆ ผมลืมแนะนำตัว ผมอาจารย์ธนพครับ ก็อยู่ที่ ม.รังสิต นะครับ และปัจจุบันเป็นแอดมินเพจ Claude Thailand Community ครับ ใครติดตามได้ เข้าไปกด Like กดอะไรได้นะครับ วันนี้เลยต้องมาตัว Claude นิดหนึ่งนะครับ ถ้าสมมติเราใช้ตัวหลักเป็น Haiku 4.5 แต่ถ้างานที่หนักๆ งานที่ต้องประมวลผลเยอะๆ ไม่ต้องการความเร็ว อาจจะไปใช้ตัว Sonnet เราควรจะตั้งไว้ เสร็จแล้วเราก็มาตั้ง system prompt ไว้ ว่าคุณจะต้อง always ใช้ตัว Haiku

แต่คุณจะ switch ไปใช้ Sonnet เมื่อไหร่ ก็ต้องบอกไว้ครับ เราต้องตั้งไว้ เพื่อให้มันใช้ตัวที่ถูกเสมอ ตัวไหนที่แพง เราก็ใช้แต่งานที่แพงๆ งานที่ต้องการประมวลผลเยอะๆ นะครับ หรือใครจะใส่เป็น Opus อะไรก็ใส่ไปนะครับ อันต่อมานะครับ อาจจะมีคนติดพวก limit rate จริงๆ สามารถตั้งใส่ไว้ใน system prompt ได้ครับ ว่าเวลาจะเรียก เราจะเรียกทุกเท่าไหร่ ยังไงนะครับ มันจะได้ไม่ติด limit rate นะครับ เพราะอย่างที่ทราบ บางทีถ้าใช้ใหม่ๆ มันเรียกยิงเข้าไปใน API เยอะ จนติด limit rate เพราะสิทธิ์การใช้ API ของแต่ละคนไม่เท่ากัน ยิ่งเราใช้เยอะๆ มันจะมีเป็น level นะครับ level 1 จะได้ limit rate เท่านี้ level 2 จะมากขึ้น level 3 จะมากขึ้น level 4 จะมากขึ้น ก็แล้วแต่ตามผู้ให้บริการ แต่เบื้องต้นที่ set default มา จะเป็น OpenAI นะครับ ซึ่งตัว OpenAI เนี่ย limit rate จะค่อนข้างน้อย เพราะมันจะตั้งเป็นตัวแพง เป็น 5.2 5.3

ราคาจะค่อนข้างสูงนะครับ ซึ่งเราสามารถ set budget รายวัน และ budget รายเดือนไว้ได้ ถ้ามันใกล้หมดก็ให้มันเตือน ไม่ใช่ว่าตื่นเช้ามาแล้วเจอไป 1,500 เหรียญ อาจจะเกิดขึ้นได้ ถ้าไม่ตั้งนะครับ

เทคนิคลดค่าใช้จ่าย Heartbeat: ใช้ Local LLM แทนการเรียก API ทุก 30 นาที17:52

อันที่ห้า อันนี้สำคัญมากครับ ตัวที่เป็น heartbeat ที่มันเรียกทุกๆ 30 นาที

ถ้าเป็นไปได้ อันนี้แนะนำเลยนะครับ ให้เราติดตัว local LLM ครับ และใช้ตัว local LLM เป็นตัวเรียกแทน ทำให้ค่าใช้จ่ายส่วนนี้กลายเป็นศูนย์ครับ แทนที่เราต้องไปเรียกตัว Opus เพื่อเรียกตัว heartbeat

แบบที่ไม่ได้ทำอะไร ใช่ไหมครับ เท่ากับว่าเราจะเสียเงินไปเปล่าๆ ฟรีๆ เลยครับ โดยที่ไม่ได้มีประโยชน์อะไรเลย ยิ่งถ้าบางคนไม่ได้ทำงานที่ต้อง trigger อะไรตลอดเวลา ต้องไปเช็คอีเมลตลอดเวลาอะไรอย่างนี้ ยิ่งเราไม่ได้ทำพวกนั้นนะ ผมแนะนำเลยให้ตั้งใช้เป็น local model ซึ่ง local model ผมแนะนำก็เป็น ตัว Llama 3.2 3B จริงๆ มี Qwen ก็ได้ Qwen ก็ได้ 8B ก็ได้ ถ้าให้ดีก็ vLLM ด้วย ขายของนิดหนึ่ง ได้หมดแล้วแต่ ผมแนะนำเป็น 3B เพราะถ้า 3B มันจะใช้แรมประมาณสัก vRAM ประมาณสัก 2 GB นะ ซึ่งมันเร็วและรองรับพวก complex context ได้ดีกว่า 1B แต่ทุกๆ วันนี้ผมตั้ง 1B อยู่ในเครื่อง Mac เก่าๆ ของผม ผมตั้ง 1B อยู่ มันก็ยังทำงานได้ปกติ ซึ่งเราก็เซตได้นะว่าจะ trigger เมื่อไหร่ครับ อันนี้ 30 วิ 30 นาที หรือ 1 ชั่วโมงก็ได้ แล้วแต่ความถี่ของความถี่ที่เราต้องการ แต่ส่วนนี้ผมแนะนำให้ตั้งนะ มีใครยังไม่ตั้งไหม อันนี้ก็จะเปลืองเงินนะ ถ้าตั้งแบบนี้

ตัวส่วนนี้ก็จะกลายเป็นศูนย์เลยครับ ไม่เสียค่าใช้จ่ายเลย อันนี้ recommend ให้ทำนะครับ

Prompt Caching: วิธีตั้งค่าแคชเพื่อลดค่า API ลงถึง 90% ในงานที่ใช้ Prompt เดิม19:28

อันต่อมา อันนี้เราเรียกว่า prompt caching ครับ ก็คือว่า เราสามารถถ้าคำ

ทุกๆ คนน่าจะทราบกันนะ ปัจจุบันเวลาเรา

สั่ง prompt ต่างๆ เนี่ย ประมาณ 80-90% มันเป็น prompt เดิมๆ ครับ ใช่ไหมครับ ที่มันอยู่ใน AGENTS.md หรือ SOUL.md มันเป็น prompt ที่ไม่เคยเปลี่ยนแปลง เป็นเหมือนเดิมตลอด ดังนั้นเราควรจะแคชมันไว้ มันจะมีบริการนะ อย่างเช่นของ Anthropic ครับ ก็คือเราสามารถแคชส่วนนั้นไว้ได้ ซึ่งจะสามารถแคชเป็น 5 นาที หรือแคชเป็น 1 ชั่วโมงก็ได้ จะสังเกตว่าเวลาแคช 5 นาที จะเสียค่าใช้จ่ายเพิ่มขึ้นอีกประมาณนิดหนึ่ง 25% มั้ง

แต่ถ้าเราแคช 1 ชั่วโมง จะเสียเพิ่มขึ้นเท่าตัวตอน write ครั้งแรก แต่หลังจากนั้นเราจะเสียลดลง 90% นะ

เป็นแค่เสียแค่ 10% ครับ เนี่ย มันหาร 10 เลยเห็นป่ะ จาก 5 กลายเป็น 0.5 ครับ มันจะลดลงเยอะมาก ดังนั้นงานที่ทำซ้ำๆ อย่างเช่นตัว agent.md ที่ไม่เคยเปลี่ยนเลย ตัว soul ที่ไม่เคยเปลี่ยนเลย ตัว user ที่ไม่เคยเปลี่ยนเลย การทำ prompt caching เนี่ย จะช่วยลดค่าใช้จ่ายประมาณ 90% ผมขอเสริมตรงนี้นิดหนึ่งครับ ถ้าสมมติว่าอยากทำบน local การทำ caching ก็สามารถใช้ vLLM ได้ จะเรียกว่า KV cache ก็คล้ายๆ ทำ prompt caching บน Anthropic เหมือนกันเป๊ะๆ เลย แต่เราสามารถ setting ให้มันรันแบบเก็บแคชไว้ และมันจะเปลือง token น้อยกว่าครับ ครับ ต่อได้เลย ตัวนี้เรื่อง prompt caching ซึ่งวิธีการตั้ง ก็ตั้งอย่างนี้ครับ เนี่ย ไปที่ตัว openclaw.json

ไปตั้งตัวพารามิเตอร์ cacheRetention ถ้า short จะคือ 5 นาที ถ้า long คือ 1 ชั่วโมง อันนี้ก็ไปตั้งได้ ก็คือถ้าเป็น 5 นาที เหมาะสำหรับคนที่คุยบ่อยๆ ครับ แต่ถ้ามันเป็นแบบตั้งเวลาหรืออะไรเนี่ย ให้เป็นสัก 1 ชั่วโมง แต่ถ้าเราคิดว่าตัว context เรามันเปลี่ยนตลอดเวลา ไม่เคยเหมือนเดิมเลยนะ ไม่ควรตั้งครับ ไม่งั้นเราจะต้องเสียเงินค่า write ครับ อาจารย์ครับ มีคำถามว่าสมมติว่าถ้าเกิดว่าเราตั้ง caching ด้วยเวลาที่มันสั้นมากๆ เนี่ย มันจะมี trade-off อะไรบ้างไหมครับ

The question was, if you end up setting your cache

very low in terms of your time, right? Exactly. What's the trade-off? Exactly. Okay. Who's going to answer? ก็ต้องลองกันครับ คือส่วนมากเนี่ย

จริงๆ ถ้าเป็นผมจะถนัด KV cache มากกว่า ซึ่งสามารถ optimize ได้เยอะกว่าตัวเมื่อกี้ มากกว่าแค่บอกว่า short, long อะไรพวกนี้ ต้องไปลองกันตัวนี้ คุณจ๊อบ ผมยังฟังไม่ทันครับ ช่วยแปลเป็นภาษาอังกฤษให้ด้วยนะครับ เมื่อกี้ถามว่าอะไรนะ อ๋อ เมื่อกี้ถามว่าไอ้ตัว caching time อะครับ ถ้าเกิดว่าเราตั้งไว้ให้มันสั้นมากๆ อย่างเงี้ย มันจะมี trade-off อะไรบ้างไหมครับผม

ตอบเองเลยเหรอ ตอบเองเลยเหรอ อ๋อ ใช่ครับ โอเค คืออันนี้ผมอาจจะไม่ได้ดู พวก architecture ข้างหลังมันดีสักเท่าไหร่ แต่ถ้าเกิดว่าเราพูดถึงการ caching อะ เราก็มักจะนึกถึงตัวของ memory ใช่ไหมครับ ไม่ว่าจะเป็น vRAM หรือตัว memory ที่ติดอยู่กับตัว computing memory นะครับผม ซึ่งการที่เรามีการ cache ที่มันบ่อยเกินไปอะ มันก็จะทำให้ไอ้ตัวของ memory เนี่ย อาจจะเกิดการ peak ขึ้นมาได้นะครับ ซึ่งถ้าเกิดว่าเรามีขนาด size memory ที่มัน limit อย่างเงี้ย มันก็จะแบบจะเต็มอยู่ตลอดเวลา และก็ compute process resource เนี่ย กราฟมันก็จะพุ่งสูงตลอดเวลา ซึ่งก็ไม่ค่อยดีเท่าไหร่ คืออันนี้ต้องไปประเมินว่า trade-off ว่าเราจะมีการ cache บ่อยขนาดไหนนั่นเองครับ ครับ ผมว่าหลักๆ มันเป็นอย่างนี้ฮะ คือผมว่า มันต้องอยู่กับการทดลองด้วยว่าไอ้งานที่เราทำอยู่ ที่เราคุยอยู่ทุกวันนี้เนี่ย มันควรจะเป็นแบบ 5 minute หรือว่าเป็น 1 ชั่วโมง เราก็ลองดูกันไปก็ได้ครับว่าอันไหนมันคุ้มกว่า เพราะไม่งั้นเดี๋ยวถ้าไม่ได้ลองเนี่ย ก็อาจจะตอบไม่ได้ถูก ก็ลองเอาเองแล้วกันนะครับ ป่ะ ไปต่อครับ

Batch Processing: ประมวลผลงานย้อนหลังเพื่อลดค่าใช้จ่ายลงครึ่งหนึ่ง23:30

เดี๋ยวไม่จบนะครับ อันต่อมามีอีกอันหนึ่งครับ ที่ถ้าใครเคยทำ LLM บ่อยๆ จะรู้ว่ามี batch processing ด้วย Batch processing ก็คือ ถ้ามันเป็นงานที่เรารอได้ ตั้งแต่ 1 ชั่วโมง ถึง 24 ชั่วโมงครับ ผมแนะนำให้ใช้ batch processing ครับ ก็คือมันจะถูกลงไปประมาณ 50%

หมายความว่ามันจะใช้กับงานลักษณะอย่างเช่น สมมติว่าเรามีงานอยากประมวลผลเกี่ยวกับว่า อ่านรูป แล้วก็เอารูปมาแบบสกัด keyword ออกมาอย่างนี้ เราไม่ต้องการ real-time ณ เดี๋ยวนี้อย่างนี้ครับ เราก็ทำ batch ไว้ก่อน แล้วก็ส่งทีเดียวเข้าไป และก็อาจจะรอประมาณ 1 ชั่วโมง หรือส่วนใหญ่จะเสร็จประมาณ 1 ชั่วโมงที่เขาเขียนไว้ในคู่มือนะ แต่ว่ามันอาจจะไปถึง 24 ชั่วโมงก็ได้ งั้นถ้ามันเป็นงานที่เรารอได้เนี่ย ผมแนะนำว่า ให้ใช้ตัว batch processing เพราะว่ามันจะลดค่าใช้จ่ายลง ประมาณ 50% นะครับ 50% ครับ

โอเค จริงๆ แล้วผมมี reference นะ ใครอยากอ่านเพิ่มเติม ผมดูมาจากอันนี้ด้วย แล้วก็ผมเพิ่มเติมส่วนตัวเข้าไปด้วย ตัว Scale Up Media อันนี้ก็ให้เครดิตเขานิดหนึ่งครับ ตัวนี้เนี่ย น่าจะมีคนเคยเห็นเนาะ มันอยู่ในออนไลน์ ใช่ไหมครับ อ่า โอเค สไลด์ ใครอยากได้สไลด์ผมแจกสไลด์นะ อันนี้เป็น AI QR ผมทำเป็นรูปแซนด์วิชกุ้งนะครับ ลองถ่ายดูครับ ไม่รู้ได้ไหม เป็น Google Slides This is a QR AI. You can try it.

ถ้าเกิดว่าลองไม่ได้ ก็พิมพ์ URL ไปนะครับ