วิธีเรียนรู้ AI Agents ตั้งแต่เริ่มต้นแบบมืออาชีพ

เส้นทาง 6 ขั้นตอน

หากต้องการเรียนรู้เรื่อง AI agents ตั้งแต่เริ่มต้น ให้ทำตาม 6 ขั้นตอนนี้ตามลำดับ ได้แก่ แนวคิด, ลูปแรกของคุณ, เครื่องมือ, หน่วยความจำ, การออกแบบลูป และความปลอดภัย แต่ละขั้นตอนจะมีสิ่งที่คุณต้องลงมือสร้างด้วยตัวเอง การข้ามขั้นตอนเป็นสาเหตุที่พบบ่อยที่สุดที่ทำให้ผู้เรียนไปต่อไม่ได้ เพราะเฟรมเวิร์กจะซ่อนรายละเอียดส่วนที่คุณจำเป็นต้องเห็นไว้

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

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

สิ่งที่คุณจำเป็นต้องมีก่อนเริ่มขั้นตอนที่ 1

รายการสิ่งที่จำเป็นต้องมีจริงๆ นั้นสั้นมาก และสั้นกว่าที่หน้าหลักสูตรส่วนใหญ่แนะนำไว้

• คุณสามารถอ่านและเขียน Python หรือ TypeScript ในระดับสคริปต์ความยาว 50 บรรทัดได้
• คุณมีความคุ้นเคยกับการใช้งาน Linux shell: ติดตั้งแพ็กเกจ, แก้ไขไฟล์, อ่าน log
• คุณมี API key สำหรับโมเดลที่โฮสต์ไว้ หรือมีเครื่องที่สามารถรันโมเดลในเครื่องได้

นั่นคือรายการทั้งหมด คุณไม่จำเป็นต้องรู้ทฤษฎี machine learning และไม่จำเป็นต้องเคยฝึกสอนโมเดลมาก่อน งานด้าน agent ไม่มีส่วนใดที่เกี่ยวข้องกับ gradients หรือข้อมูลสำหรับการฝึกสอน (training data) การ์ดจอจะมีความสำคัญก็ต่อเมื่อคุณตัดสินใจรันโมเดลด้วยตัวเอง ซึ่งเป็นทักษะแยกต่างหากที่คุณสามารถเรียนรู้ได้ในภายหลังผ่าน การโฮสต์ Ollama บน VPS เพื่อรัน LLM ด้วยตัวเอง

สิ่งที่ผู้คนมักประเมินต่ำไปคือส่วนของ shell ตัว agent มักล้มเหลวเนื่องจากปัญหาเรื่องสิทธิ์ (permissions), path, environment variables และกระบวนการทำงานที่หยุดไปโดยไม่มีการแจ้งเตือน หาก stack trace เกี่ยวกับ PATH หรือโหมดของไฟล์ทำให้คุณต้องปิด terminal ให้ใช้เวลาช่วงสุดสัปดาห์ศึกษาพื้นฐาน Linux ก่อน สิ่งนี้จะช่วยประหยัดเวลาให้คุณได้เป็นเดือนในภายหลัง

ขั้นตอนที่ 1: เอเจนต์คืออะไร และไม่ใช่สิ่งใด

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

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

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

ขั้นตอนที่ 2: เขียนลูปด้วยตัวเองหนึ่งครั้ง

อย่าเริ่มต้นด้วยเฟรมเวิร์ก ให้เขียนโค้ด Python ประมาณ 30 บรรทัดเพื่อให้คุณเข้าใจโครงสร้างของมันด้วยตัวเอง

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in response.content if b.type == "text"))

รันโค้ดด้วย python3 agent.py หากการทำงานปกติ โปรแกรมจะพิมพ์ย่อหน้าหนึ่งที่ระบุชื่อระบบไฟล์และพื้นที่ว่างที่เหลืออยู่ เพราะโมเดลได้ร้องขอ df -h โค้ดของคุณจึงรันคำสั่งนั้น และการประมวลผลรอบที่สองจะเปลี่ยนตารางดังกล่าวให้เป็นประโยค หากไม่มีข้อความใดแสดงออกมา แสดงว่าลูปสิ้นสุดลงก่อนที่บล็อกข้อความจะมาถึง ให้เพิ่ม print(response.stop_reason) เข้าไปในลูปเพื่อดูการเปลี่ยนแปลงของค่าต่างๆ

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

คำเตือนประการหนึ่งเกี่ยวกับตัวอย่างนี้ คือมันส่งผลลัพธ์จากโมเดลเข้าสู่เชลล์โดยตรงด้วย shell=True ซึ่งเป็นสิ่งที่ยอมรับได้บนเครื่องทดสอบที่คุณสามารถล้างเครื่องลงใหม่ได้ แต่เป็นวิธีที่ผิดในทุกกรณีอื่น ขั้นตอนที่ 6 จะแก้ไขปัญหานี้ แนวคิดภายใต้ลูปนี้ได้รับการอธิบายไว้อย่างละเอียดใน การสร้าง AI agent ของคุณเองบน VPS

ขั้นตอนที่ 3: เครื่องมือที่เอเจนต์ยังไม่มี

เครื่องมือ run_command ของคุณทำงานได้ แต่เอเจนต์ที่ใช้งานจริงจำเป็นต้องมีเครื่องมือที่เข้าถึงภายนอกกล่องได้ เช่น ระบบจัดการตั๋ว (ticket system), ฐานข้อมูล หรือที่เก็บซอร์สโค้ด การเขียน wrapper เฉพาะสำหรับแต่ละบริการและแต่ละเอเจนต์นั้นไม่สามารถขยายระบบได้

Model Context Protocol (MCP) คือคำตอบที่อุตสาหกรรมเลือกใช้ MCP server จะเปิดเผยชุดเครื่องมือผ่านช่องทางการสื่อสารที่เป็นมาตรฐาน และเอเจนต์ที่รองรับ MCP ทุกตัวสามารถใช้งานได้โดยไม่ต้องเขียนโค้ดเชื่อมต่อเพิ่มเติม ตัวอย่าง reference filesystem server สามารถเรียกใช้ได้ด้วยคำสั่งเดียว:

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

คำสั่งนี้จำเป็นต้องติดตั้ง Node และอาร์กิวเมนต์ directory คือ path เดียวที่เซิร์ฟเวอร์จะเข้าถึง นี่คือรูปแบบความปลอดภัยในระดับย่อส่วน: เซิร์ฟเวอร์เป็นผู้กำหนดขอบเขต ไม่ใช่ตัวโมเดล เมื่อชี้ไคลเอนต์ไปยังเซิร์ฟเวอร์นี้ เอเจนต์ของคุณจะได้รับความสามารถในการอ่านและเขียนไฟล์โดยที่คุณไม่ต้องเขียนโค้ดเอง การรันเครื่องมือเหล่านี้อย่างถูกต้องภายใต้ service account และการเลือกช่องทางการสื่อสารที่อธิบายไว้ มีรายละเอียดอยู่ใน การรัน MCP servers บน VPS สำหรับเอเจนต์เขียนโค้ด AI

บทเรียนของขั้นตอนนี้คือการออกแบบเครื่องมือคืองานที่แท้จริง คำอธิบายที่คลุมเครือจะทำให้โมเดลต้องเดา เครื่องมือที่ส่งข้อมูลกลับมาสี่หมื่นตัวอักษรจะทำให้ context window เต็มไปด้วยข้อมูลขยะ และเครื่องมือที่สามารถลบข้อมูลได้ ในที่สุดมันก็จะลบข้อมูลเข้าสักวันหนึ่ง

ขั้นตอนที่ 4: หน่วยความจำ ซึ่งส่วนใหญ่เป็นเพียงไฟล์

ผู้เริ่มต้นมักจะมองหา vector database ในขั้นตอนนี้ แต่ขอให้คุณอย่าเพิ่งทำเช่นนั้น อย่างน้อยก็ในตอนนี้

Agent ไม่มีหน่วยความจำระหว่างการเรียกใช้งาน คุณต้องส่งบทสนทนาทั้งหมดไปใหม่ทุกครั้ง ซึ่งเป็นเหตุผลว่าทำไมเซสชันที่ยาวนานจึงมีค่าใช้จ่ายต่อรอบสูงกว่าเซสชันที่สั้น ดังนั้นหน่วยความจำจึงถูกแบ่งออกเป็นสองปัญหา ปัญหาแรกคือสิ่งที่พอดีกับ context window ในขณะนั้น ซึ่งคุณสามารถจัดการได้ด้วยการสรุปเนื้อหา การตัดผลลัพธ์จากเครื่องมือเก่าๆ ออก และการทำ caching ส่วนนำของ prompt ที่คงที่ เพื่อให้คุณจ่ายค่าใช้จ่ายเพียงเศษเสี้ยวสำหรับส่วนนั้น ปัญหาที่สองคือสิ่งที่ยังคงอยู่หลังจากการรีสตาร์ท ซึ่งก็คือการจัดเก็บข้อมูล

สำหรับปัญหาที่สอง ไฟล์ markdown ธรรมดาที่ Agent สามารถอ่านและเขียนได้นั้นมีประสิทธิภาพเหนือกว่า vector database สำหรับโปรเจกต์เริ่มต้นเกือบทุกประเภท ให้ไฟล์แก่ Agent หนึ่งไฟล์ ระบุรูปแบบไฟล์ บอกให้ Agent อ่านไฟล์นั้นก่อนเริ่มงาน และอัปเดตไฟล์เมื่อเรียนรู้สิ่งใหม่ คุณจะได้รับประโยชน์เกือบทั้งหมด และคุณยังสามารถเปิดไฟล์เพื่อดูสิ่งที่ Agent ของคุณรับรู้ได้ ให้หันไปใช้ embeddings และการดึงข้อมูล (retrieval) ก็ต่อเมื่อบันทึกเหล่านั้นไม่สามารถใส่ใน context window ได้อีกต่อไป และอย่าทำก่อนหน้านั้น

ขั้นตอนที่ 5: ลูปคือตัวผลิตภัณฑ์

ในตอนนี้คุณสามารถสร้างเอเจนต์ที่ทำงานได้ในขณะที่คุณเฝ้าดูอยู่ ขั้นตอนที่ 5 คือการทำให้มันทำงานได้ในขณะที่คุณไม่ได้เฝ้าดู

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

แบบฝึกหัด: นำเอเจนต์จากขั้นตอนที่ 2 ของคุณมาใช้ มอบหมายงานที่ต้องใช้ 4 หรือ 5 ขั้นตอน และเพิ่มการจำกัดจำนวนรอบ (iteration cap) ที่เข้มงวด จากนั้นให้เอาการจำกัดนั้นออกแล้วสังเกตว่าลูปที่ไม่มีขอบเขตส่งผลอย่างไรต่อค่าใช้จ่าย token ของคุณ ให้ทำเช่นนี้หนึ่งครั้งด้วยงบประมาณที่จำกัด เพื่อที่คุณจะได้ไม่เผลอทำพลาดจนเกิดค่าใช้จ่ายมหาศาลในอนาคต

ขั้นตอนที่ 6: ความปลอดภัย, ความลับ และค่าใช้จ่าย

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

ให้รัน agent ด้วยผู้ใช้ที่ไม่มีสิทธิ์ (unprivileged user) ของตนเอง ห้ามรันในฐานะ root หรือบัญชีผู้ใช้ของคุณโดยเด็ดขาด เพื่อจำกัดขอบเขตความเสียหายให้เหลือเพียงแค่ไดเรกทอรี ไม่ใช่ทั้งเครื่อง เก็บข้อมูลรับรอง (credentials) ให้พ้นจากการเข้าถึงของโมเดล เนื่องจากข้อมูลใดก็ตามที่อยู่ใน context window อาจถูกดึงออกมาผ่านการเรียกใช้เครื่องมือ (tool call) ได้ วิธีแก้ไขคือการใช้โทเค็นที่มีอายุการใช้งานสั้นและจำกัดขอบเขตผ่าน helper ตามที่อธิบายไว้ใน การเก็บความลับให้พ้นจาก AI agent ของคุณ กำหนดเพดานค่าใช้จ่ายไว้ให้ชัดเจน เนื่องจากลูปที่ทำงานโดยไม่มีผู้ดูแลจะสร้างค่าใช้จ่ายในทุกรอบการทำงานโดยไม่มีใครตรวจสอบ ซึ่งการกำหนดขีดจำกัดและการทำ batching เพื่อควบคุมสถานการณ์ได้อธิบายไว้ใน การควบคุมค่าใช้จ่าย AI agent บน VPS ที่ทำงานตลอดเวลา

ค่าใช้จ่ายเป็นเรื่องที่ต้องระบุตัวเลขให้ชัดเจน ณ เดือนกรกฎาคม 2026 โมเดล Claude Opus 5 มีค่าใช้จ่าย 5 ดอลลาร์ต่อ 1 ล้าน input tokens และ 25 ดอลลาร์ต่อ 1 ล้าน output tokens ซึ่ง agent ที่มีการโต้ตอบสูงและส่งบทสนทนาที่ยาวขึ้นเรื่อยๆ อาจใช้โทเค็นถึงหลักแสนต่อหนึ่งงาน การใช้ Prompt caching และการใช้โมเดลขนาดเล็กสำหรับขั้นตอนทั่วไป จะช่วยเปลี่ยนตัวเลขเหล่านี้ได้มากกว่าการปรับแต่ง prompt ใดๆ

เรื่อง Prompt injection ก็ควรพิจารณาในขั้นตอนนี้เช่นกัน หาก agent ของคุณอ่านหน้าเว็บ, ระบบติดตามปัญหา (issue tracker) หรือกล่องข้อความ ผู้ที่เขียนข้อความเหล่านั้นก็เท่ากับกำลังเขียนคำสั่งให้ agent ของคุณด้วย การป้องกันไม่ใช่การใช้ system prompt ที่ฉลาดขึ้น แต่คือการกำหนดขอบเขต (boundary) เพราะ agent ที่ไม่มีสิทธิ์ลบ repository ก็ย่อมไม่สามารถถูกหลอกให้ลบมันได้

คุณควรปฏิบัติตามแผนการเรียนใด?

ให้เลือกหลักสูตรเพียงหนึ่งหลักสูตรและเรียนให้จบ แทนที่จะทดลองเรียนไปเรื่อยๆ หลายหลักสูตร คลังเก็บโค้ด ai-agents-for-beginners ของ Microsoft เป็นหลักสูตรฟรีที่สมบูรณ์ที่สุด โดยเป็นคอร์สเรียน 18 บทที่ได้รับความนิยมสูงถึง 70,000 stars ณ เดือนกรกฎาคม 2026 และมีเนื้อหาที่สอดคล้องกับขั้นตอนต่างๆ ที่กล่าวมาข้างต้นอย่างชัดเจน การรวบรวมคลังเก็บโค้ดของ agent ที่กำลังเป็นกระแสมีประโยชน์สำหรับการดูว่ามีเครื่องมืออะไรบ้าง แต่ไม่เหมาะที่จะใช้เป็นหลักสูตรการเรียน เนื่องจากรายการที่เรียงลำดับตามจำนวน stars จะเรียงตามความนิยม ไม่ใช่เรียงตามลำดับการเรียนรู้

เมื่อคุณต้องการโปรเจกต์จริงเพื่อฝึกฝน coding agent คือเป้าหมายแรกที่ดีที่สุด เพราะคุณจะได้รับผลตอบรับทันที เครื่องมือที่ใช้มีความชัดเจน และความผิดพลาดสามารถแก้ไขได้ง่าย การรัน coding AI agent บน VPS จะอธิบายขั้นตอนการทำงานตั้งแต่ต้นจนจบ หากคุณต้องการศึกษาจากระบบที่ทำงานได้จริงแทนการสร้างจากศูนย์ การเปรียบเทียบใน AI agent แบบ self-hosted ที่ดีที่สุด จะแสดงให้เห็นว่าแต่ละโปรเจกต์มีวิธีการแก้ปัญหาในลูปการทำงานเดียวกันอย่างไร

ใช้เวลานานเท่าใด

สำหรับผู้ที่มีพื้นฐานการเขียนโปรแกรมอยู่แล้ว ขั้นตอนที่ 1 และ 2 จะใช้เวลาเพียงหนึ่งเย็น ส่วนขั้นตอนที่ 3 จะใช้เวลาหนึ่งสุดสัปดาห์ โดยส่วนใหญ่จะหมดไปกับการทำความเข้าใจคำอธิบายเครื่องมือมากกว่าตัวโปรโตคอล ขั้นตอนที่ 4 และ 5 จะใช้เวลาใช้งานจริงสองสามสัปดาห์ เนื่องจากคุณจะเรียนรู้สิ่งที่เอเจนต์ของคุณลืมได้ก็ต่อเมื่อเฝ้าสังเกตในขณะที่มันลืมเท่านั้น ขั้นตอนที่ 6 ไม่มีวันเสร็จสิ้นอย่างสมบูรณ์ ในแง่ที่ว่าความสามารถใหม่ทุกอย่างที่คุณมอบให้จะทำให้ขั้นตอนนี้กลับมาเริ่มต้นใหม่เสมอ

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

FAQ

ฉันจำเป็นต้องมีความรู้ด้าน machine learning เพื่อสร้าง AI agent หรือไม่?

ไม่จำเป็น การสร้าง agent คือการเรียกใช้งานโมเดลผ่าน API และเชื่อมต่อคำขอใช้งานเครื่องมือ (tool requests) เข้ากับฟังก์ชันการทำงานจริง ซึ่งเป็นงานเขียนโปรแกรมประยุกต์ทั่วไป คุณไม่จำเป็นต้องยุ่งเกี่ยวกับกระบวนการฝึกสอน (training), gradients หรือชุดข้อมูล ทักษะที่ตัดสินว่า agent ของคุณจะทำงานได้หรือไม่คือการออกแบบ schema สำหรับเครื่องมือ, การจัดการข้อผิดพลาด (error handling) และสิทธิ์การเข้าถึงไฟล์ใน Linux ทฤษฎี machine learning จะมีความเกี่ยวข้องก็ต่อเมื่อคุณต้องการปรับแต่งโมเดล (fine-tune) ซึ่งเป็นงานที่ต่างออกไปและมีข้อกำหนดเบื้องต้นที่แตกต่างกัน

ฉันควรเริ่มต้นด้วย framework อย่าง LangChain หรือ CrewAI เลยหรือไม่?

ควรเขียนลูปการทำงานพื้นฐานด้วยตัวเองก่อน แล้วค่อยนำ framework มาใช้ framework จะเข้ามาแทนที่โค้ดประมาณ 30 บรรทัดในขั้นตอนที่ 2 ด้วย configuration object ซึ่งจะสะดวกก็ต่อเมื่อคุณเข้าใจแล้วว่ามันเข้ามาแทนที่อะไร หากคุณยังไม่เข้าใจจะทำให้เกิดความสับสน เมื่อ agent ของคุณทำงานผิดพลาด คุณจำเป็นต้องวิเคราะห์รายการข้อความ (message list) และผลลัพธ์จากเครื่องมือโดยตรง ซึ่งจะทำได้ยากมากหากคุณไม่เคยเห็นโครงสร้างเหล่านั้นมาก่อน หลังจากที่คุณเขียนลูปด้วยตัวเองได้หนึ่งรอบแล้ว framework จะช่วยประหยัดเวลาให้คุณได้จริง แทนที่จะเป็นการปกปิดกลไกการทำงาน

การเรียนรู้เรื่อง AI agent มีค่าใช้จ่ายเท่าไร?

น้อยกว่าที่คนส่วนใหญ่คาดคิดหากมีการจำกัดงบประมาณ การมี API key และ VPS ขนาดเล็กเพียงหนึ่งเครื่องก็เพียงพอสำหรับทั้ง 6 ขั้นตอนในบทเรียนนี้ ความเสี่ยงที่แท้จริงไม่ใช่ค่าบริการรายชั่วโมง แต่คือการที่ลูปทำงานไม่สิ้นสุดและเรียกเก็บเงินทุกรอบในขณะที่คุณนอนหลับ ดังนั้นควรตั้งค่าจำกัดการใช้จ่าย (hard spend limit) ในบัญชี API ตั้งแต่วันแรก, เพิ่มการจำกัดจำนวนรอบ (iteration cap) ในทุกลูปที่คุณเขียน และใช้โมเดลที่มีราคาถูกกว่าสำหรับขั้นตอนทั่วไป การรันโมเดลบนเครื่องตัวเอง (locally) จะช่วยตัดค่าใช้จ่ายด้าน token ออกไป แต่จะเปลี่ยนเป็นความต้องการด้านฮาร์ดแวร์แทน

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

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