วิธีเรียนรู้ AI Agents ตั้งแต่เริ่มต้นใน 6 ขั้นตอน

เส้นทาง 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 หนึ่งครั้งโดยไม่มีการวนซ้ำ ส่งพรอมต์ พิมพ์คำตอบที่ได้รับ และดูจำนวนโทเค็นในคำตอบนั้น คุณจะเข้าใจหน่วยของค่าใช้จ่ายและหน่วยของความหน่วง (latency) ในตอนนี้

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

หาก agent ของคุณทำงานภายใน harness แทนที่จะเป็นสคริปต์ที่คุณเขียนเอง ขั้นตอนนี้บางส่วนจะเป็นเรื่องของการกำหนดค่า (configuration) มากกว่าการเขียนโค้ด และ ปลั๊กอิน DeepSeek Harness ที่ควรติดตั้ง จะครอบคลุมเนื้อหาในส่วนนี้ ทั้งเรื่องการกำหนดเพดานงบประมาณ กฎการอนุญาตใช้เครื่องมือ และการสแกนการฉีดคำสั่ง (injection scanning)

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

การฉีดคำสั่ง (prompt injection) ก็อยู่ในขั้นตอนนี้เช่นกัน หาก agent ของคุณอ่านหน้าเว็บ, ระบบติดตามปัญหา (issue tracker) หรือกล่องข้อความ ผู้ที่เขียนข้อความเหล่านั้นก็เท่ากับกำลังเขียนคำสั่งให้ agent ของคุณด้วย การค้นหาผ่านเว็บ (web search) มักเป็นเครื่องมือแรกที่เปิดช่องทางนี้ และ การเชื่อมต่อ agent เข้ากับ SearXNG instance ของคุณเอง จะแสดงให้เห็นถึงการเชื่อมต่อและพื้นผิวที่เสี่ยงต่อการถูกฉีดคำสั่งไปพร้อมๆ กัน การป้องกันไม่ใช่การใช้ 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 คือการเรียกใช้ model ผ่าน API และเชื่อมต่อคำขอใช้งานเครื่องมือ (tool requests) เข้ากับฟังก์ชันการทำงานจริง ซึ่งเป็นงานเขียนโปรแกรมประยุกต์ทั่วไป คุณไม่จำเป็นต้องยุ่งเกี่ยวกับกระบวนการฝึกสอน (training), ค่า gradients หรือชุดข้อมูล (datasets) ทักษะที่ตัดสินว่า agent ของคุณจะทำงานได้หรือไม่คือการออกแบบ schema สำหรับเครื่องมือ, การจัดการข้อผิดพลาด (error handling) และสิทธิ์การเข้าถึงใน Linux ทฤษฎี machine learning จะมีความสำคัญก็ต่อเมื่อคุณต้องการปรับแต่ง model (fine-tune) ซึ่งเป็นงานคนละประเภทและมีข้อกำหนดเบื้องต้นที่แตกต่างกัน

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

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

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

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

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

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