วิธีสร้าง AI Agent ของตัวเองด้วย Python และ LangChain ฉบับมือใหม่

ในโลกของปัญญาประดิษฐ์ที่พัฒนาไปอย่างก้าวกระโดด เราได้เห็นศักยภาพของ Large Language Models (LLMs) ในการสนทนา ตอบคำถาม และสร้างสรรค์สิ่งต่างๆ มากมาย แต่ถ้าเราอยากให้ AI ทำอะไรที่ซับซ้อนกว่านั้น เช่น วางแผน เลือกใช้เครื่องมือ หรือแม้แต่เรียนรู้จากประสบการณ์ที่ผ่านมาล่ะ? นี่แหละครับคือจุดที่ “AI Agent” เข้ามามีบทบาท

ในฐานะคนที่คลุกคลีกับการพัฒนา AI มาพักใหญ่ ผมบอกได้เลยว่า AI Agent คือก้าวต่อไปที่น่าตื่นเต้น มันไม่ใช่แค่โมเดลที่รอรับคำสั่งอีกต่อไป แต่มันมีความสามารถในการ “คิด” วางแผน และลงมือทำเพื่อบรรลุเป้าหมายที่ได้รับมอบหมาย และข่าวดีคือเราสามารถสร้าง Agent ของตัวเองได้ง่ายขึ้นกว่าที่คิด ด้วยพลังของ Python และ LangChain ครับ บทความนี้ผมจะพาคุณไปเจาะลึกวิธีการสร้าง AI Agent ตั้งแต่ศูนย์ จนคุณสามารถสร้าง Agent ที่มีประโยชน์จริงได้ด้วยตัวเอง

AI Agent คืออะไร ทำไมต้องสร้างเอง?

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

Agent แตกต่างจาก LLM ทั่วไปตรงที่มันมีองค์ประกอบสำคัญสามอย่าง:

1. **สมอง (Brain):** คือ LLM นั่นเอง ทำหน้าที่ในการให้เหตุผล วางแผน และตัดสินใจ
2. **เครื่องมือ (Tools):** คือความสามารถหรือฟังก์ชันที่ Agent สามารถเรียกใช้ได้ เพื่อโต้ตอบกับโลกภายนอก เช่น การค้นหาข้อมูลบนอินเทอร์เน็ต การอ่านอีเมล การคำนวณ หรือแม้แต่การเรียกใช้ API ของระบบอื่นๆ
3. **ความทรงจำ (Memory):** ช่วยให้ Agent จดจำบริบทการสนทนา หรือประสบการณ์ที่ผ่านมา เพื่อนำมาปรับปรุงการตัดสินใจในอนาคต

การสร้าง AI Agent ของตัวเองช่วยให้เราสร้างระบบที่ปรับแต่งมาเพื่อแก้ปัญหาเฉพาะทางได้ ไม่ว่าจะเป็นการสรุปข่าวสารรายวัน การจัดการข้อมูล การทำวิจัย หรือแม้แต่การเขียนโค้ดอัตโนมัติ มันคือการปลดล็อกศักยภาพของ AI ให้ทำงานได้อย่างอิสระและมีประสิทธิภาพมากขึ้น

เตรียมความพร้อม: ติดตั้ง LangChain และตั้งค่า API Keys

ก่อนที่เราจะเริ่มลงมือโค้ดกัน สิ่งแรกที่ต้องทำคือเตรียมสภาพแวดล้อมให้พร้อมครับ LangChain เป็นเฟรมเวิร์กที่ยอดเยี่ยมที่ช่วยให้เราสร้างและจัดการ LLM applications ได้อย่างง่ายดาย

ติดตั้ง LangChain

เราจะใช้ `pip` ในการติดตั้ง LangChain และส่วนประกอบที่จำเป็นอื่นๆ รวมถึงไลบรารีสำหรับ LLM ที่เราจะใช้ เช่น OpenAI หรือ Google Gemini (ถ้าคุณใช้ Gemini) รวมถึง `beautifulsoup4` สำหรับการดึงข้อมูลจากหน้าเว็บในภายหลัง

pip install langchain langchain-openai beautifulsoup4
# หรือถ้าคุณต้องการใช้ Google Gemini
# pip install langchain-google-genai

ตั้งค่า API Key

Agent ของเราจะต้องเข้าถึงโมเดล LLM อย่าง OpenAI หรือ Gemini ซึ่งต้องใช้ API Key คุณควรเก็บ API Key ไว้ในตัวแปรสภาพแวดล้อม (Environment Variable) เพื่อความปลอดภัย ไม่ควร hardcode ลงไปในโค้ดโดยตรงครับ

สำหรับ OpenAI:

export OPENAI_API_KEY='sk-your-openai-api-key-here'

สำหรับ Google Gemini:

export GOOGLE_API_KEY='your-gemini-api-key-here'

หรือคุณอาจจะสร้างไฟล์ `.env` ในโปรเจกต์ของคุณแล้วใช้ไลบรารี `python-dotenv` เพื่อโหลดค่าก็ได้เช่นกันครับ:

# ในไฟล์ .env
OPENAI_API_KEY='sk-your-openai-api-key-here'

# ในโค้ด Python
import os
from dotenv import load_dotenv

load_dotenv()
# os.environ["OPENAI_API_KEY"] จะมีค่าแล้ว

**เคล็ดลับสำคัญ:** การจัดการ API Key อย่างปลอดภัยเป็นสิ่งสำคัญมาก ห้ามเผยแพร่ API Key ของคุณสู่สาธารณะเด็ดขาด!

หัวใจของ Agent: LLM, Prompt และ Tools

ก่อนจะไปถึงโค้ดตัวเต็ม มาทำความเข้าใจองค์ประกอบหลักสามอย่างที่ Agent ของเราจะต้องมีกันก่อนครับ

LLM: โมเดลภาษาอัจฉริยะ

นี่คือ “สมอง” ของ Agent มันทำหน้าที่ให้เหตุผล ตัดสินใจว่าจะใช้เครื่องมือใด หรือจะตอบสนองอย่างไร เราจะใช้โมเดลประเภท Chat Model เช่น `ChatOpenAI` หรือ `ChatGoogleGenerativeAI` ครับ

from langchain_openai import ChatOpenAI
# from langchain_google_genai import ChatGoogleGenerativeAI # สำหรับ Gemini

llm = ChatOpenAI(model="gpt-4o", temperature=0) # ใช้ GPT-4o หรือรุ่นอื่นๆ
# llm = ChatGoogleGenerativeAI(model="gemini-pro", temperature=0) # สำหรับ Gemini

`temperature=0` มักจะถูกใช้ใน Agent เพื่อให้ผลลัพธ์มีความสอดคล้องและไม่สร้างสรรค์จนเกินไป ช่วยให้ Agent มีความน่าเชื่อถือในการตัดสินใจ

Tools: แขนขาให้ Agent ทำงาน

Tools คือฟังก์ชันที่ Agent สามารถเรียกใช้ได้เพื่อโต้ตอบกับโลกภายนอก LangChain มี Tools สำเร็จรูปให้เลือกใช้มากมาย เช่น Search, Calculator หรือเราจะสร้าง Tool ของตัวเองก็ได้

ตัวอย่าง Tools สำเร็จรูป:

from langchain_community.tools import DuckDuckGoSearchRun

search_tool = DuckDuckGoSearchRun()

`DuckDuckGoSearchRun` ช่วยให้ Agent ค้นหาข้อมูลบนอินเทอร์เน็ตได้

Prompt: แผนที่นำทาง

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

Agent ใน LangChain มักจะใช้ Prompt ที่มีโครงสร้างเฉพาะ เพื่อให้ LLM สามารถใช้ ReAct Pattern ได้ (ซึ่งจะอธิบายในภายหลัง)

มาสร้าง Agent ตัวแรกของเรากัน!

ได้เวลาลงมือสร้าง Agent ตัวแรกที่สามารถใช้เครื่องมือค้นหาข้อมูลได้ เพื่อตอบคำถามทั่วไปกันแล้วครับ

LangChain มี Agent หลายประเภท แต่ `create_react_agent` เป็นจุดเริ่มต้นที่ดีสำหรับผู้เริ่มต้น เพราะมันใช้ ReAct pattern ที่ช่วยให้ Agent คิดวิเคราะห์และเลือกใช้ Tool ได้อย่างมีเหตุผล

ReAct Pattern คืออะไร?

ReAct ย่อมาจาก “Reasoning” (การให้เหตุผล) และ “Acting” (การกระทำ) มันคือการที่ Agent มีกระบวนการคิดวนลูปดังนี้:
1. **Thought (ความคิด):** Agent คิดว่าปัญหาคืออะไร ต้องทำอะไรต่อไป ควรใช้ Tool อะไร
2. **Action (การกระทำ):** Agent เลือก Tool และพารามิเตอร์ที่ต้องการ ส่งออกไปเรียกใช้ Tool นั้น
3. **Observation (การสังเกต):** Agent ได้รับผลลัพธ์จากการเรียกใช้ Tool นั้น
4. วนกลับไปที่ **Thought** อีกครั้ง เพื่อประเมินผลลัพธ์และตัดสินใจขั้นต่อไป จนกว่าจะได้คำตอบสุดท้าย

ตัวอย่างโค้ด: Agent ค้นหาข้อมูลทั่วไป

import os
from dotenv import load_dotenv

# โหลด environment variables จาก .env
load_dotenv()

from langchain_openai import ChatOpenAI
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.prompts import ChatPromptTemplate
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.messages import HumanMessage, AIMessage

# 1. เตรียม LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 2. เตรียม Tools
tools = [
    DuckDuckGoSearchRun(name="Search", description="Useful for when you need to answer questions about current events or facts. Input should be a search query.")
]

# 3. เตรียม Prompt Template
# นี่คือ System Prompt พื้นฐานสำหรับ ReAct Agent
# มันจะบอก Agent ว่ามีหน้าที่อะไร และมี Tools อะไรบ้าง
prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful AI assistant. You have access to the following tools: {tools}"),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}") # ส่วนนี้สำหรับเก็บ Thought, Action, Observation
    ]
)

# 4. สร้าง Agent
# create_react_agent จะรวม LLM, Tools และ Prompt เข้าด้วยกัน
agent = create_react_agent(llm, tools, prompt_template)

# 5. สร้าง Agent Executor
# Agent Executor คือส่วนที่รัน Agent และจัดการการวนลูปของ ReAct Pattern
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 6. เรียกใช้งาน Agent
print("Running Agent with query: 'ข่าวสารเทคโนโลยีล่าสุดในประเทศไทยคืออะไร?'")
result = agent_executor.invoke({"input": "ข่าวสารเทคโนโลยีล่าสุดในประเทศไทยคืออะไร?"})
print("\n--- Agent Response ---")
print(result["output"])

print("\nRunning Agent with query: 'กรุงเทพฯ เป็นเมืองหลวงของประเทศอะไร?'")
result = agent_executor.invoke({"input": "กรุงเทพฯ เป็นเมืองหลวงของประเทศอะไร?"})
print("\n--- Agent Response ---")
print(result["output"])

เมื่อคุณรันโค้ดนี้ คุณจะเห็น `Thought`, `Action`, `Observation` ปรากฏขึ้นมา นั่นคือการที่ Agent กำลังคิดและใช้งาน Tool อย่างมีเหตุผลครับ `verbose=True` ช่วยให้เราเห็นกระบวนการคิดของ Agent

เพิ่มความสามารถให้ Agent: Memory และ Custom Tools

Agent ที่แค่ค้นหาข้อมูลได้อาจจะยังไม่พอ เราอยากให้มันมีความจำ และสามารถทำอะไรที่เฉพาะเจาะจงมากขึ้นได้

Memory: ความทรงจำของ Agent

Memory ช่วยให้ Agent จดจำการสนทนาที่ผ่านมา ทำให้การโต้ตอบเป็นธรรมชาติและต่อเนื่องมากขึ้น

import os
from dotenv import load_dotenv

load_dotenv()

from langchain_openai import ChatOpenAI
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import create_react_agent, AgentExecutor
from langchain.memory import ConversationBufferMemory
from langchain_core.messages import HumanMessage, AIMessage

llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [DuckDuckGoSearchRun(name="Search", description="Useful for when you need to answer questions about current events or facts. Input should be a search query.")]

# Prompt Template ที่มี MessagesPlaceholder สำหรับ Memory
prompt_template_with_memory = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful AI assistant. You have access to the following tools: {tools}"),
        MessagesPlaceholder(variable_name="chat_history"), # เพิ่มส่วนนี้สำหรับประวัติการสนทนา
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad")
    ]
)

# เพิ่ม Memory ให้กับ Agent
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

agent_with_memory = create_react_agent(llm, tools, prompt_template_with_memory)
agent_executor_with_memory = AgentExecutor(
    agent=agent_with_memory,
    tools=tools,
    verbose=True,
    memory=memory # ส่ง Memory เข้าไป
)

print("Running Agent with Memory...")
# การเรียกใช้งาน Agent ที่มี Memory ต้องส่ง chat_history เปล่าๆ ไปก่อนในครั้งแรก
# หรือจะใช้ invoke ปกติ ถ้า memory ถูกจัดการใน AgentExecutor อยู่แล้ว (ซึ่งมันจัดการให้)

print("\n--- รอบที่ 1 ---")
result1 = agent_executor_with_memory.invoke({"input": "ประเทศอะไรเป็นเจ้าภาพโอลิมปิกฤดูร้อน 2024?"})
print("\nAgent Response 1:", result1["output"])

print("\n--- รอบที่ 2 ---")
# ในรอบที่ 2 Agent จะจำได้ว่าคุยอะไรไปบ้าง
result2 = agent_executor_with_memory.invoke({"input": "ประเทศนั้นเคยเป็นเจ้าภาพมาก่อนไหม?"})
print("\nAgent Response 2:", result2["output"])

จะเห็นว่าในรอบที่สอง Agent สามารถเข้าใจคำว่า “ประเทศนั้น” ได้เพราะมี `chat_history` ที่ช่วยให้มันจดจำบริบทการสนทนาได้

สร้าง Tool ของตัวเอง: ตัวอย่างตัวสรุปข่าวสาร

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

import os
from dotenv import load_dotenv
import requests
from bs4 import BeautifulSoup

load_dotenv()

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool # decorator สำหรับสร้าง tool ง่ายๆ
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import create_react_agent, AgentExecutor
from langchain.memory import ConversationBufferMemory

# --- 1. เตรียม LLM ---
llm_for_agent = ChatOpenAI(model="gpt-4o", temperature=0)
llm_for_summarization = ChatOpenAI(model="gpt-4o", temperature=0.2) # อาจจะให้มี creative นิดหน่อยในการสรุป

# --- 2. สร้าง Custom Tool สำหรับสรุปข่าวสาร ---
@tool
def summarize_web_page(url: str) -> str:
    """
    Reads the content of a given URL, extracts the main text, and summarizes it using an LLM.
    Useful for getting a quick summary of a news article or web page.
    """
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status() # ตรวจสอบข้อผิดพลาด HTTP

        soup = BeautifulSoup(response.text, 'html.parser')

        # พยายามหาเนื้อหาหลักของบทความ (อาจต้องปรับตามโครงสร้างเว็บ)
        # ตัวอย่างนี้ลองหา p tag ทั้งหมดที่อยู่ใน div/article หลัก
        main_content_tags = soup.find_all(['p', 'h1', 'h2', 'h3', 'li'])
        article_text = "\n".join([tag.get_text() for tag in main_content_tags if tag.get_text().strip()])

        if not article_text:
            return "Could not extract sufficient text from the webpage."

        # จำกัดความยาวของข้อความที่จะส่งไปให้ LLM สรุป
        # LLM มีข้อจำกัดเรื่อง context window และการประมวลผลข้อความยาวๆ มีค่าใช้จ่ายสูง
        max_summary_length = 8000
        if len(article_text) > max_summary_length:
            article_text = article_text[:max_summary_length] + "..." # ตัดข้อความถ้ามันยาวเกินไป

        # ใช้ LLM สรุปเนื้อหา
        summary_prompt = ChatPromptTemplate.from_messages([
            ("system", "คุณคือผู้ช่วยที่เชี่ยวชาญในการสรุปข่าวสารจากบทความเว็บเพจ จงสรุปเนื้อหาหลักของบทความต่อไปนี้ให้กระชับและเข้าใจง่ายเป็นภาษาไทย โดยเน้นประเด็นสำคัญๆ เท่านั้น"),
            ("human", f"บทความที่จะสรุป:\n{article_text}")
        ])
        summary_chain = summary_prompt | llm_for_summarization
        summary = summary_chain.invoke({"article_text": article_text}).content
        
        return f"สรุปจาก {url}:\n{summary}"

    except requests.exceptions.RequestException as e:
        return f"Error accessing the URL: {e}"
    except Exception as e:
        return f"An unexpected error occurred: {e}"

# --- 3. เตรียม Tools ทั้งหมดสำหรับ Agent ---
tools_for_news_agent = [
    DuckDuckGoSearchRun(name="Search", description="Useful for when you need to answer questions about current events or facts. Input should be a search query."),
    summarize_web_page # เพิ่ม Custom Tool ของเรา
]

# --- 4. เตรียม Prompt Template พร้อม Memory ---
news_agent_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "คุณคือ AI Agent ผู้เชี่ยวชาญด้านข่าวสารและการสรุปบทความ คุณสามารถค้นหาข้อมูลบนอินเทอร์เน็ตและสรุปเนื้อหาจากลิงก์ที่ได้รับมอบหมายได้ จงตอบคำถามของผู้ใช้ให้ถูกต้องและกระชับที่สุด และใช้เครื่องมืออย่างเหมาะสม คุณมีเครื่องมือดังนี้: {tools}"),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad")
    ]
)

# --- 5. สร้าง Agent และ Agent Executor ---
memory_for_news_agent = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

news_agent = create_react_agent(llm_for_agent, tools_for_news_agent, news_agent_prompt)
news_agent_executor = AgentExecutor(
    agent=news_agent,
    tools=tools_for_news_agent,
    verbose=True,
    memory=memory_for_news_agent
)

# --- 6. เรียกใช้งาน Agent ---
print("Running News Summarizer Agent...\n")

print("--- สถานการณ์ที่ 1: ค้นหาข่าวแล้วสรุป ---")
# ลองให้ Agent ค้นหาข่าวแล้วสรุป
query1 = "ข่าวล่าสุดเกี่ยวกับ AI ในประเทศไทยคืออะไร แล้วสรุปมาให้เข้าใจง่ายๆ หน่อย"
result1 = news_agent_executor.invoke({"input": query1})
print("\nAgent Response 1:\n", result1["output"])

print("\n--- สถานการณ์ที่ 2: สรุปจาก URL ที่กำหนด ---")
# ลองให้ Agent สรุปจาก URL โดยตรง (ตัวอย่างลิงก์ข่าว)
# **ข้อควรระวัง:** เว็บไซต์บางแห่งอาจมีมาตรการป้องกันการ Scraping
# กรุณาใช้ลิงก์ที่สามารถเข้าถึงได้และเป็นสาธารณะ
query2 = "สรุปข่าวจากลิงก์นี้ให้หน่อย: https://www.thaipbs.or.th/news/content/339230"
result2 = news_agent_executor.invoke({"input": query2})
print("\nAgent Response 2:\n", result2["output"])

print("\n--- สถานการณ์ที่ 3: ถามคำถามต่อเนื่อง ---")
query3 = "มีข้อดีและข้อเสียของการนำ AI มาใช้ในอุตสาหกรรมไทยตามข่าวนี้อย่างไรบ้าง?"
result3 = news_agent_executor.invoke({"input": query3})
print("\nAgent Response 3:\n", result3["output"])

โค้ดข้างต้นแสดงให้เห็นว่า Agent ของเราสามารถ:
* ค้นหาข้อมูลทั่วไปเกี่ยวกับ AI ในประเทศไทย
* เมื่อเจอ URL ที่น่าสนใจ (หรือได้รับ URL โดยตรง) สามารถเรียกใช้ Tool `summarize_web_page` เพื่อดึงข้อมูลและให้ LLM สรุป
* จดจำบริบทการสนทนาเพื่อตอบคำถามต่อเนื่องเกี่ยวกับข่าวที่เพิ่งสรุปไป

**ข้อควรพิจารณา:** การดึงข้อมูลจากเว็บด้วย `BeautifulSoup` อาจไม่ได้ผลกับทุกเว็บไซต์ โดยเฉพาะเว็บที่มี JavaScript เยอะๆ หรือมีมาตรการป้องกันการ Scrape นอกจากนี้ เว็บไซต์มีการเปลี่ยนแปลงโครงสร้างได้ตลอดเวลา ซึ่งอาจทำให้ Tool ของเราทำงานผิดพลาดได้ครับ

สรุป

การสร้าง AI Agent ด้วย Python และ LangChain เป็นกระบวนการที่น่าตื่นเต้นและเปิดโลกทัศน์ใหม่ๆ ให้กับผู้ที่ต้องการสร้างระบบ AI ที่ชาญฉลาดและมีความสามารถรอบด้าน

เราได้เริ่มต้นจากการทำความเข้าใจแนวคิดพื้นฐานของ AI Agent, การติดตั้ง LangChain, การตั้งค่า API Key ไปจนถึงการสร้าง Agent ตัวแรกที่สามารถค้นหาข้อมูลได้ด้วย `DuckDuckGoSearchRun` และที่สำคัญที่สุด เราได้พัฒนา Agent ให้มีความฉลาดขึ้นด้วยการเพิ่ม `Memory` และสร้าง `Custom Tool` อย่าง `summarize_web_page` ที่ช่วยให้ Agent ของเราสามารถดึงและสรุปข้อมูลจากเว็บไซต์ได้

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

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