การเขียน CrewAI เชื่อมต่อ GPT-4o-mini ด้วย Python

#การเขียน CrewAI เชื่อมต่อ GPT-4o-mini ด้วย Python

infographic

การพัฒนาแอปพลิเคชันด้วย Large Language Model หรือ LLM ไม่จำเป็นต้องจำกัดอยู่เพียงการส่ง Prompt ไปยังโมเดลแล้วรอรับคำตอบกลับมาเท่านั้น เราสามารถออกแบบระบบให้มี AI Agent หลายตัว ซึ่งแต่ละตัวมีบทบาท ความรับผิดชอบ และเป้าหมายแตกต่างกัน จากนั้นให้ Agent เหล่านั้นทำงานร่วมกันเป็นลำดับได้

CrewAI เป็นเฟรมเวิร์กภาษา Python สำหรับสร้างและควบคุมการทำงานของ AI Agent โดยมีองค์ประกอบสำคัญ ได้แก่ Agent, Task, Crew และ Process ส่วน GPT-4o-mini เป็นโมเดลขนาดเล็กที่เหมาะกับงานเฉพาะด้าน เช่น การสรุปข้อมูล การจัดหมวดหมู่ การสร้างเนื้อหา การสกัดข้อมูล และการเรียกใช้เครื่องมือผ่าน Function Calling

บทความนี้จะแสดงวิธีเชื่อมต่อ CrewAI กับ GPT-4o-mini ตั้งแต่การติดตั้ง การจัดการ API Key การสร้าง Agent และ Task ไปจนถึงการรัน Multi-Agent Workflow แบบ Sequential

#ภาพรวมการทำงาน

โครงสร้างการทำงานพื้นฐานสามารถอธิบายได้ดังนี้

User Prompt
    ↓
CrewAI Crew
    ↓
Agent ตัวที่ 1: วิเคราะห์ข้อมูล
    ↓
Agent ตัวที่ 2: เรียบเรียงผลลัพธ์
    ↓
GPT-4o-mini ประมวลผลแต่ละ Task
    ↓
Final Result

CrewAI ทำหน้าที่เป็นตัวควบคุม Workflow ส่วน GPT-4o-mini ทำหน้าที่เป็น LLM ที่อยู่เบื้องหลังความสามารถด้านภาษาและการตัดสินใจของ Agent

#องค์ประกอบสำคัญของ CrewAI

ก่อนเริ่มเขียนโค้ด ควรทำความเข้าใจองค์ประกอบหลักของ CrewAI

#Agent

Agent คือผู้ปฏิบัติงานในระบบ แต่ละ Agent ควรกำหนดข้อมูลอย่างน้อยดังนี้

role บทบาทของ Agent
goal เป้าหมายที่ Agent ต้องทำให้สำเร็จ
backstory บริบทหรือความเชี่ยวชาญของ Agent
llm โมเดลภาษาที่ Agent ใช้งาน
tools เครื่องมือที่ Agent สามารถเรียกใช้ได้

#Task

Task คืองานที่มอบหมายให้ Agent โดยควรกำหนดรายละเอียดของงานและรูปแบบผลลัพธ์ที่ต้องการอย่างชัดเจน

description คำอธิบายงาน
expected_output ลักษณะผลลัพธ์ที่คาดหวัง
agent Agent ที่รับผิดชอบ
context ผลลัพธ์จาก Task ก่อนหน้าที่นำมาใช้เป็นบริบท

#Crew

Crew คือทีมที่รวม Agent และ Task เข้าด้วยกัน พร้อมกำหนดกระบวนการทำงาน

#Process

Process คือรูปแบบการประมวลผลงาน ตัวอย่างที่ใช้บ่อย ได้แก่

Process.sequential ทำงานตามลำดับที่กำหนด
Process.hierarchical มี Manager Agent ควบคุมและมอบหมายงาน

สำหรับผู้เริ่มต้น ควรเริ่มจาก Process.sequential เพราะทำความเข้าใจและตรวจสอบผลลัพธ์ได้ง่ายกว่า

#สิ่งที่ต้องเตรียม

ก่อนเริ่มต้น ควรมีสิ่งต่อไปนี้

Python เวอร์ชันที่ CrewAI รองรับ
OpenAI API Key
โปรแกรมแก้ไขโค้ด เช่น Visual Studio Code
Terminal หรือ Command Prompt
บัญชี OpenAI API ที่เปิดใช้งาน Billing หรือมีเครดิตเพียงพอ

CrewAI เวอร์ชันปัจจุบันกำหนดให้ใช้ Python ตั้งแต่ 3.10 ขึ้นไป แต่ต่ำกว่า 3.14

ตรวจสอบเวอร์ชัน Python ด้วยคำสั่ง

python --version

หรือบนบางระบบ

python3 --version

#ขั้นตอนที่ 1: สร้างโปรเจกต์

ตัวอย่างนี้ใช้ uv สำหรับจัดการ Virtual Environment และ Dependency

uv init crewai-gpt4o-mini
cd crewai-gpt4o-mini

ติดตั้ง CrewAI พร้อมส่วนเชื่อมต่อ OpenAI และ python-dotenv

uv add "crewai[openai]" python-dotenv

กรณีใช้ pip สามารถสร้าง Virtual Environment และติดตั้งแพ็กเกจได้ดังนี้

#Windows

python -m venv .venv
.venv\Scripts\activate
pip install "crewai[openai]" python-dotenv

#macOS หรือ Linux

python3 -m venv .venv
source .venv/bin/activate
pip install "crewai[openai]" python-dotenv

#ขั้นตอนที่ 2: ตั้งค่า OpenAI API Key

สร้างไฟล์ชื่อ .env ไว้ในโฟลเดอร์หลักของโปรเจกต์

OPENAI_API_KEY=sk-your-openai-api-key
MODEL=openai/gpt-4o-mini

ชื่อโมเดลที่ส่งให้ CrewAI ควรมี Provider Prefix คือ

openai/gpt-4o-mini

การใส่ openai/ ไว้ด้านหน้าช่วยให้ CrewAI ทราบว่าโมเดลดังกล่าวต้องเรียกผ่าน OpenAI Provider

จากนั้นสร้างไฟล์ .gitignore

.env
.venv/
__pycache__/
*.pyc

ไม่ควรเขียน API Key ฝังลงใน Source Code และไม่ควร Commit ไฟล์ .env ขึ้น Git Repository

#ขั้นตอนที่ 3: สร้าง Agent ตัวแรก

สร้างไฟล์ main.py และเพิ่มโค้ดดังนี้

import os

from crewai import Agent, Crew, LLM, Process, Task
from dotenv import load_dotenv


def create_llm() -> LLM:
    """สร้าง LLM สำหรับเชื่อมต่อ OpenAI ผ่าน CrewAI."""

    load_dotenv()

    if not os.getenv("OPENAI_API_KEY"):
        raise RuntimeError(
            "ไม่พบ OPENAI_API_KEY กรุณากำหนดค่าในไฟล์ .env"
        )

    return LLM(
        model=os.getenv("MODEL", "openai/gpt-4o-mini"),
        temperature=0.2,
        timeout=60,
    )


def main() -> None:
    llm = create_llm()

    assistant = Agent(
        role="ผู้ช่วยสรุปเนื้อหาด้านเทคโนโลยี",
        goal="สรุปเรื่องที่ได้รับให้ถูกต้อง กระชับ และเข้าใจง่าย",
        backstory=(
            "คุณเป็นผู้เชี่ยวชาญด้านเทคโนโลยีและการสื่อสาร "
            "สามารถอธิบายเรื่องที่ซับซ้อนให้ผู้เริ่มต้นเข้าใจได้"
        ),
        llm=llm,
        verbose=True,
        allow_delegation=False,
    )

    summary_task = Task(
        description=(
            "อธิบายหัวข้อ '{topic}' เป็นภาษาไทย "
            "โดยระบุความหมาย หลักการทำงาน ประโยชน์ "
            "และตัวอย่างการนำไปใช้"
        ),
        expected_output=(
            "บทสรุปภาษาไทยในรูปแบบ Markdown "
            "ประกอบด้วยชื่อเรื่อง หัวข้อย่อย และตัวอย่างใช้งาน"
        ),
        agent=assistant,
        markdown=True,
    )

    crew = Crew(
        agents=[assistant],
        tasks=[summary_task],
        process=Process.sequential,
        verbose=True,
    )

    result = crew.kickoff(
        inputs={
            "topic": "การประยุกต์ใช้ Generative AI ในการศึกษา"
        }
    )

    print("\n" + "=" * 60)
    print("ผลลัพธ์")
    print("=" * 60)
    print(result.raw)


if __name__ == "__main__":
    main()

#อธิบายโค้ดส่วนสำคัญ

#การสร้าง LLM

llm = LLM(
    model="openai/gpt-4o-mini",
    temperature=0.2,
    timeout=60,
)

พารามิเตอร์สำคัญประกอบด้วย

model ระบุ Provider และชื่อโมเดล
temperature ควบคุมระดับความหลากหลายของคำตอบ
timeout กำหนดเวลาสูงสุดที่รอการตอบกลับ

ค่า temperature ต่ำ เช่น 0.0-0.3 เหมาะกับงานที่ต้องการผลลัพธ์ค่อนข้างคงที่ เช่น การสรุป การจำแนกประเภท และการสกัดข้อมูล ส่วนค่าที่สูงขึ้นเหมาะกับงานสร้างสรรค์มากกว่า

#การสร้าง Agent

assistant = Agent(
    role="ผู้ช่วยสรุปเนื้อหาด้านเทคโนโลยี",
    goal="สรุปเรื่องที่ได้รับให้ถูกต้อง กระชับ และเข้าใจง่าย",
    backstory="คุณเป็นผู้เชี่ยวชาญด้านเทคโนโลยี",
    llm=llm,
)

การกำหนด role, goal และ backstory ให้ชัดเจนช่วยจำกัดขอบเขตการทำงานของ Agent และลดโอกาสที่ผลลัพธ์จะออกนอกประเด็น

#การสร้าง Task

summary_task = Task(
    description="อธิบายหัวข้อ '{topic}' เป็นภาษาไทย",
    expected_output="บทสรุปภาษาไทยในรูปแบบ Markdown",
    agent=assistant,
)

ตัวแปร {topic} จะถูกแทนค่าจากข้อมูลที่ส่งผ่าน crew.kickoff(inputs={...})

#การเริ่มทำงานด้วย `kickoff()`

result = crew.kickoff(
    inputs={"topic": "Generative AI ในการศึกษา"}
)

เมธอด kickoff() จะเริ่มประมวลผล Task ตาม Process ที่กำหนด และส่งผลลัพธ์กลับมาเป็น Crew Output

#ขั้นตอนที่ 4: รันโปรแกรม

กรณีใช้ uv

uv run python main.py

กรณีเปิดใช้งาน Virtual Environment แล้ว

python main.py

ระหว่างการทำงาน หากกำหนด verbose=True โปรแกรมจะแสดงรายละเอียดการทำงานของ Agent ซึ่งมีประโยชน์สำหรับการตรวจสอบ Prompt, Task และลำดับการประมวลผล

#ตัวอย่าง Multi-Agent Workflow

จุดเด่นของ CrewAI คือการแยกความรับผิดชอบออกเป็น Agent หลายตัว ตัวอย่างต่อไปนี้ประกอบด้วย

Analyst Agent ทำหน้าที่วิเคราะห์หัวข้อ
Writer Agent นำผลการวิเคราะห์มาเรียบเรียงเป็นบทความ

import os

from crewai import Agent, Crew, LLM, Process, Task
from dotenv import load_dotenv

load_dotenv()

if not os.getenv("OPENAI_API_KEY"):
    raise RuntimeError("ไม่พบ OPENAI_API_KEY ในไฟล์ .env")

llm = LLM(
    model=os.getenv("MODEL", "openai/gpt-4o-mini"),
    temperature=0.3,
    timeout=60,
)

analyst = Agent(
    role="นักวิเคราะห์เทคโนโลยี",
    goal="วิเคราะห์หัวข้อและจัดโครงสร้างสาระสำคัญอย่างเป็นระบบ",
    backstory=(
        "คุณมีประสบการณ์ด้านซอฟต์แวร์และปัญญาประดิษฐ์ "
        "สามารถแยกข้อเท็จจริง ประโยชน์ ข้อจำกัด และกรณีใช้งานได้"
    ),
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

writer = Agent(
    role="นักเขียนบทความเทคโนโลยี",
    goal="เขียนบทความภาษาไทยที่ถูกต้อง อ่านง่าย และพร้อมเผยแพร่",
    backstory=(
        "คุณเชี่ยวชาญการเรียบเรียงเนื้อหาทางเทคนิค "
        "ให้เหมาะกับนักศึกษาและนักพัฒนาระดับเริ่มต้น"
    ),
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

analysis_task = Task(
    description=(
        "วิเคราะห์หัวข้อ '{topic}' โดยสรุปความหมาย "
        "หลักการทำงาน ประโยชน์ ข้อจำกัด และตัวอย่างใช้งาน"
    ),
    expected_output=(
        "รายงานวิเคราะห์ภาษาไทยที่แบ่งหัวข้อชัดเจน "
        "พร้อมประเด็นสำคัญสำหรับนำไปเขียนบทความ"
    ),
    agent=analyst,
)

writing_task = Task(
    description=(
        "ใช้ผลการวิเคราะห์จาก Task ก่อนหน้า "
        "เขียนเป็นบทความภาษาไทยสำหรับเผยแพร่บน Blog "
        "ประกอบด้วยบทนำ เนื้อหา ตัวอย่าง และบทสรุป"
    ),
    expected_output=(
        "บทความภาษาไทยรูปแบบ Markdown "
        "มีชื่อเรื่อง หัวข้อย่อย Code Block และบทสรุป"
    ),
    agent=writer,
    context=[analysis_task],
    markdown=True,
)

crew = Crew(
    agents=[analyst, writer],
    tasks=[analysis_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff(
    inputs={
        "topic": "การใช้ AI Agent ช่วยพัฒนาซอฟต์แวร์"
    }
)

print(result.raw)

ในตัวอย่างนี้ writing_task กำหนด context=[analysis_task] ทำให้ Writer Agent สามารถนำผลลัพธ์จาก Analyst Agent มาใช้เป็นข้อมูลประกอบการเขียนได้

#การแยกโมเดลให้ Agent แต่ละตัว

CrewAI อนุญาตให้ Agent แต่ละตัวใช้ LLM ต่างกันได้ ตัวอย่างเช่น Agent สำหรับงานทั่วไปใช้ GPT-4o-mini ส่วน Agent ที่ต้องการความสามารถสูงกว่าอาจใช้โมเดลอื่น

from crewai import Agent, LLM

fast_llm = LLM(
    model="openai/gpt-4o-mini",
    temperature=0.2,
)

classifier = Agent(
    role="ผู้จำแนกข้อความ",
    goal="จำแนกข้อความตามหมวดหมู่ที่กำหนด",
    backstory="คุณเชี่ยวชาญงาน Text Classification",
    llm=fast_llm,
)

แนวทางนี้ช่วยควบคุมต้นทุนและเวลาในการประมวลผล โดยเลือกใช้โมเดลให้เหมาะกับความซับซ้อนของแต่ละ Task

#งานที่เหมาะกับ GPT-4o-mini ใน CrewAI

GPT-4o-mini เหมาะกับ Agent ที่ทำงานเฉพาะด้านและมีขอบเขตชัดเจน เช่น

สรุปบทความ เอกสาร หรือข้อความ
จัดหมวดหมู่ข้อความและวิเคราะห์ Intent
สกัดข้อมูลให้อยู่ในรูปแบบที่กำหนด
เขียนคำอธิบายสินค้าและเนื้อหาสำหรับเว็บไซต์
สร้างคำถาม แบบฝึกหัด หรือบทเรียน
แปลและปรับรูปแบบภาษา
เรียกใช้ Tools หรือ Function Calling
สร้าง Structured Output สำหรับส่งต่อให้ระบบอื่น
ทำงานเป็น Agent ย่อยใน Multi-Agent Workflow

แม้โมเดลจะรองรับบริบทขนาดใหญ่ แต่ควรแบ่งเอกสารขนาดใหญ่ออกเป็นส่วนย่อย ใช้ RAG หรือใช้ Knowledge Source แทนการส่งข้อมูลทั้งหมดเข้า Prompt ครั้งเดียว

#ปัญหาที่พบบ่อยและแนวทางแก้ไข

#1. ไม่พบ `OPENAI_API_KEY`

ตรวจสอบว่าไฟล์ .env อยู่ในโฟลเดอร์เดียวกับโปรแกรม และมีคำสั่ง

load_dotenv()

ตรวจสอบโดยไม่แสดง API Key จริง

print(bool(os.getenv("OPENAI_API_KEY")))

หากแสดง True หมายความว่าโปรแกรมโหลดค่าได้แล้ว

#2. ระบุชื่อโมเดลไม่ถูกต้อง

ควรใช้

model="openai/gpt-4o-mini"

ไม่ควรใช้ชื่อที่มีช่องว่างหรือสะกดต่างจาก Model ID

model="GPT-4o mini"

#3. เกิด Authentication Error

ตรวจสอบว่า

API Key ถูกต้องและยังใช้งานได้
ไม่มีช่องว่างก่อนหรือหลัง API Key
บัญชี API มีสิทธิ์เรียกใช้โมเดล
โปรเจกต์ OpenAI มี Billing หรือเครดิตเพียงพอ

#4. เกิด Rate Limit Error

ลดจำนวนคำขอพร้อมกัน กำหนด max_rpm หรือเพิ่มกลไก Retry ตามความเหมาะสม

agent = Agent(
    role="ผู้ช่วย AI",
    goal="ประมวลผลงานตามที่ได้รับ",
    backstory="ผู้ช่วยด้านข้อมูล",
    llm=llm,
    max_rpm=20,
)

#5. ผลลัพธ์ไม่ตรงรูปแบบ

ปรับ expected_output ให้ชัดเจน เช่น ระบุหัวข้อ จำนวนรายการ รูปแบบ Markdown หรือ Schema ที่ต้องการ หากระบบนำผลลัพธ์ไปประมวลผลต่อ ควรใช้ Structured Output ร่วมกับ Pydantic

#6. Agent ทำงานซ้ำหรือใช้เวลานาน

ลดค่า max_iter และกำหนด Task ให้แคบลง

agent = Agent(
    role="นักสรุปข้อมูล",
    goal="สรุปเนื้อหาไม่เกิน 5 ประเด็น",
    backstory="ผู้เชี่ยวชาญด้านการสรุป",
    llm=llm,
    max_iter=5,
)

#แนวทางสำหรับนำไปใช้ใน Production

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

#จัดการ Secret อย่างปลอดภัย

Production ควรเก็บ API Key ใน Secret Manager หรือ Environment Variable ของแพลตฟอร์ม ไม่ควรเก็บไว้ในไฟล์ที่อยู่ใน Repository

#ตรวจสอบผลลัพธ์

ควรสร้าง Guardrail หรือ Validation เพื่อตรวจสอบว่า Agent ส่งผลลัพธ์ตามรูปแบบที่ระบบต้องการ

#บันทึก Log และ Metrics

ติดตามข้อมูลสำคัญ เช่น

ระยะเวลาการทำงานของแต่ละ Task
จำนวน Token ที่ใช้
จำนวนครั้งที่ Retry
ความผิดพลาดจาก API
ค่าใช้จ่ายโดยประมาณ

#จำกัดขอบเขตของ Tools

Agent ควรได้รับเฉพาะ Tools ที่จำเป็นต่อ Task เท่านั้น โดยเฉพาะเครื่องมือที่สามารถแก้ไขฐานข้อมูล ส่งอีเมล หรือเรียกใช้คำสั่งในระบบ

#ใช้ Human-in-the-Loop กับงานสำคัญ

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

#สรุป

การเชื่อมต่อ CrewAI กับ GPT-4o-mini ช่วยให้นักพัฒนาสามารถสร้าง AI Agent และ Multi-Agent Workflow ได้โดยไม่ต้องเขียนระบบ Orchestration ทั้งหมดขึ้นเอง หลักการสำคัญคือแยกงานออกเป็น Agent และ Task ที่มีขอบเขตชัดเจน จากนั้นใช้ Crew ควบคุมลำดับการทำงาน

ขั้นตอนหลักประกอบด้วย

ติดตั้ง crewai[openai] และ python-dotenv
กำหนด OPENAI_API_KEY ในไฟล์ .env
สร้าง LLM ด้วยโมเดล openai/gpt-4o-mini
กำหนด Agent ด้วย Role, Goal และ Backstory
กำหนด Task พร้อม Expected Output
รวม Agent และ Task เป็น Crew
เริ่มทำงานด้วย crew.kickoff()

เมื่อเข้าใจโครงสร้างพื้นฐานแล้ว สามารถต่อยอดไปสู่ระบบที่ซับซ้อนขึ้น เช่น Research Agent, Content Generation Pipeline, Customer Support Agent, RAG Agent, Data Analysis Agent และระบบ Workflow อัตโนมัติที่เชื่อมต่อกับ API หรือฐานข้อมูลภายนอก

TL;DR