# จาก chatbot ธรรมดา สู่ AI ที่ทำงานแทนเราได้ — เราเติมอะไรเข้าไปบ้าง? > Source: > Published: 2026-07-01 01:30:51+00:00 เวลาเราใช้ ChatGPT หรือ Claude ครั้งแรก — เราพิมพ์คำถาม ได้คำตอบ จบ นั่นคือ **LLM (Large Language Model)** ในรูปแบบพื้นฐานที่สุด: ข้อความเข้า → ข้อความออก แต่อยู่ ๆ มาวันหนึ่งเราเห็น AI ที่: **เราเติมอะไรลงไปบ้าง?** — จาก chatbot ธรรมดากลายเป็น agent ได้ยังไง? LLM คือ "เครื่องทำนายคำถัดไป" — มันเห็นข้อความก่อนหน้า แล้วเดาว่าคำต่อไปควรเป็นอะไร ``` [ผู้ใช้ถาม] → [LLM] → [คำตอบ] ``` สิ่งที่ LLM **ทำไม่ได้** ในสภาพนี้: มันคือสมองที่เก่ง — แต่ไม่มีแขน ไม่มีขา ไม่มีความจำ สิ่งแรกที่เราเติม: **system prompt** — ข้อความที่บอก LLM ว่า "คุณเป็นใคร" และ "คุณทำอะไรได้บ้าง" ``` คุณคือ AI ผู้ช่วยชื่อ Hermes คุณทำงานบนเครื่อง Linux ของผู้ใช้ คุณตอบเป็นภาษาไทย อ่านง่าย เป็นกันเอง ``` System prompt คือ **"job description"** ของ AI — มันเปลี่ยน LLM จาก "เครื่องทำนายคำ" เป็น "ผู้ช่วยที่มีตัวตน" LLM เก่งเรื่องภาษา แต่มันกดเครื่องคิดเลขไม่เป็น — เราก็เลยให้ **เครื่องมือ (tools)** กับมัน วิธีทำงาน: ``` 1. ผู้ใช้: "เช็คสภาพอากาศกรุงเทพวันนี้" 2. LLM คิด: "ฉันต้องเรียกฟังก์ชัน get_weather(city='Bangkok')" 3. ระบบ: เรียก get_weather() จริง → ได้ผลลัพธ์ { temp: 35, humidity: 70 } 4. ระบบ: ส่งผลลัพธ์กลับไปให้ LLM 5. LLM: "วันนี้กรุงเทพ 35 องศา ความชื้น 70% ครับ" ``` **Tools ที่เราให้ AI ได้:** | Tool | ตัวอย่าง | LLM ทำอะไร | |---|---|---| | Web search | `search("ราคาทองวันนี้")` | ค้นเน็ต | | File read | `read_file("config.yaml")` | อ่านไฟล์ | | Terminal | `terminal("git status")` | รันคำสั่ง | | Database | `query("SELECT * FROM users")` | ถาม database | **สิ่งที่เปลี่ยน:** LLM ไม่ได้แค่ "พูด" แล้ว — มัน "ทำ" ได้แล้ว tool ครั้งเดียวอาจไม่พอ — LLM อาจต้องเรียก tool หลายรอบเพื่อทำงานชิ้นหนึ่งให้เสร็จ ``` 1. ผู้ใช้: "สร้างไฟล์ README.md ให้ project นี้" 2. LLM → tool: read_file("main.go") ← อ่านก่อนว่ามีอะไร 3. LLM → tool: search_files("*.go") ← หาไฟล์ทั้งหมด 4. LLM → tool: read_file("go.mod") ← อ่าน module name 5. LLM → tool: write_file("README.md") ← เขียน! 6. LLM → ผู้ใช้: "สร้าง README.md เสร็จแล้วครับ" ``` นี่คือ **Agent Loop** — วงจร "คิด → เรียก tool → ดูผล → คิดต่อ → เรียก tool อีก" — ไปเรื่อย ๆ จนกว่างานจะเสร็จ 💡 สังเกต:ตอนนี้ LLM ไม่ได้ตอบทันทีแล้ว — มันใช้เวลา "ทำงาน" หลายวินาที หรือหลายนาที Loop ช่วยให้ AI ทำงานต่อเนื่องใน session เดียว — แต่พอปิด session ทุกอย่างหายหมด เราเติม **memory** — ระบบจดจำสิ่งที่เกิดขึ้นข้าม session: ``` Session 1: ผู้ใช้บอกว่า "ผมใช้ Go เป็นหลัก ชอบ pattern แบบนี้" Session 2: AI ทักว่า "คราวที่แล้วคุณบอกว่าชอบ table-driven test — จะใช้ pattern นั้นไหม?" ← จำได้! ``` Memory เก็บอะไร: LLM เก่งเรื่องตอบคำถาม — แต่เวลาเจองานซับซ้อน มันอาจ "ทำเลย" โดยไม่คิดก่อน เราเติม **reasoning** — บังคับให้ AI "คิดดัง ๆ" ก่อนลงมือ: ``` ผู้ใช้: "หา condo ในกรุงเทพ ราคา 7-8 ล้าน ขนาด ≥60 ตรม." AI คิด (reasoning): "1. ต้องเข้าเว็บ led.go.th 2. กรอกฟอร์ม: ประเภท=ห้องชุด, จังหวัด=กรุงเทพ, ราคา=7-8M, ขนาด≥60 3. แต่เว็บมี CAPTCHA — ต้องอ่าน CAPTCHA ทีหลังสุด 4. ต้องใช้ button.click() — form.submit() ใช้ไม่ได้ 5. ถ้าไม่มีในห้วยขวาง → ขยายเป็นทั้งกรุงเทพ" AI ลงมือทำตามแผน → สำเร็จ ``` นี่คือ **reasoning** — AI ไม่ได้ตอบทันที แต่มัน "คิด" ก่อน — แล้วค่อยทำตามแผน พอ AI ทำงานซ้ำ ๆ — เราอยากให้มัน "จำวิธีทำ" และใช้ซ้ำได้โดยไม่ต้องคิดใหม่ทุกครั้ง เราเติม **skills** — ไฟล์ที่บรรจุ "วิธีการทำงานที่พิสูจน์แล้ว": ``` # Skill: deepseek-balance วิธีเช็คยอดเงิน DeepSeek: 1. อ่าน key จาก ~/.bashrc 2. เรียก curl https://api.deepseek.com/user/balance 3. แสดงผลเป็นภาษาไทย ``` คราวหน้าเวลา AI ต้องเช็คยอด — มันโหลด skill นี้ → ทำตามขั้นตอน → เสร็จใน 3 วิ — ไม่ต้องคิดใหม่ Skill = **"ประสบการณ์ที่บันทึกไว้"** — เหมือน SOP ขององค์กร งานบางอย่างใหญ่มาก — AI ตัวเดียวทำงานไม่ทัน เราเติม **delegation** — AI spawn ลูกน้องไปทำงานย่อย: ``` [AI หลัก] → "งานนี้มี 3 อย่าง: 1) research Go 1.27, 2) เขียน blog, 3) โพสต์" → spawn subagent 1: research Go 1.27 → spawn subagent 2: ออกแบบโครงสร้าง blog → รอผล → เขียน blog → โพสต์ ``` ทำงานพร้อมกัน — เสร็จเร็วขึ้น — เหมือนมีทีมช่วย เอา Layer ทั้งหมดมารวมกัน: ``` LLM เปล่า + System Prompt → มี "ตัวตน" + Tool Calling → มี "มือ" ทำงานได้ + Loop → ทำงานต่อเนื่อง ไม่ใช่ตอบทีเดียวจบ + Memory → จำได้ข้าม session + Reasoning → คิดก่อนทำ + Skills → ใช้ประสบการณ์ซ้ำ + Multi-Agent → มีทีมช่วย ───────────────────────────────────── = Agentic AI ``` Agentic AI ไม่ได้ฉลาดกว่า LLM — มันแค่มี **"เครื่องมือ"** มากกว่า และถูกออกแบบให้ **"ทำงาน"** ไม่ใช่แค่ **"ตอบ"** ``` ┌──────────────────────────┐ │ User: "สร้าง API" │ └──────────┬───────────────┘ ▼ ┌──────────────────────────┐ │ System Prompt: กติกา │ ← "คุณเป็น dev ที่ใช้ Go" └──────────┬───────────────┘ ▼ ┌──────────────────────────┐ │ Reasoning: คิดก่อน │ ← "ต้องสร้าง handler, service, repo" └──────────┬───────────────┘ ▼ ┌────────────────┼────────────────┐ ▼ ▼ ▼ ┌─────────┐ ┌──────────┐ ┌──────────┐ │ Tool │ │ Tool │ │ Tool │ │ อ่าน │ │ เขียน │ │ รัน │ │ โค้ด │ │ ไฟล์ │ │ test │ └────┬────┘ └────┬─────┘ └────┬─────┘ │ │ │ └──────────────┼───────────────┘ ▼ ┌──────────────────────────┐ │ Loop: ทำซ้ำจนกว่าจะเสร็จ │ └──────────┬───────────────┘ ▼ ┌──────────────────────────┐ │ Memory: บันทึกสิ่งที่เรียนรู้ │ ← "คราวหน้าใช้วิธีนี้" └──────────────────────────┘ ``` พอเข้าใจตรงนี้แล้ว — เวลาอ่านเรื่อง **MCP (Model Context Protocol)**, **ACP (Agent Client Protocol)**, **RAG (Retrieval-Augmented Generation)** — คุณจะเห็นว่ามันคือ layer ที่เติมเข้าไปเพิ่ม: ทั้งหมดคือการเติม "layer" — และทั้งหมดเริ่มจาก LLM เปล่า ๆ ตัวเดียว 📚 อ่านต่อ: [Aider — Pair Programming กับ AI ใน Terminal]— ตัวอย่าง agentic AI ที่ใช้จริง[Anthropic: Building effective agents]— แนวคิดการออกแบบ agentic system