OpenAI Agents SDK เป็นไลบรารี Python ที่ออกแบบมาเพื่อลดความซับซ้อนในการพัฒนาตัวแทน AI ที่ขับเคลื่อนด้วยโมเดลภาษาของ OpenAI ซึ่งช่วยให้นักพัฒนาสามารถสร้างตัวแทนเฉพาะงาน ผสานรวมฟังก์ชันการทำงานภายนอก จัดการการมอบหมายงานระหว่างตัวแทน บังคับใช้การตรวจสอบความถูกต้องของอินพุต/เอาต์พุต และตรวจสอบโฟลว์การดำเนินการ คู่มือนี้จะให้คำแนะนำทางเทคนิคโดยละเอียดเกี่ยวกับการติดตั้ง การกำหนดค่า และการใช้ประโยชน์จาก SDK อย่างมีประสิทธิภาพ เพื่อให้มั่นใจว่ามีคำอย่างน้อย 2000 คำ โดยเน้นที่ความแม่นยำและการประยุกต์ใช้จริง
บทนำ
OpenAI Agents SDK มีกรอบการทำงานที่มีโครงสร้างสำหรับการสร้างระบบหลายตัวแทน โดยที่ตัวแทนแต่ละรายได้รับการปรับแต่งให้ทำงานเฉพาะอย่าง ตัวแทนเหล่านี้สามารถโต้ตอบกับผู้ใช้ ดำเนินการผ่านเครื่องมือที่ผสานรวม และทำงานร่วมกันโดยการส่งต่องานไปยังตัวแทนอื่น ส่วนประกอบสำคัญของ SDK ได้แก่:
- ตัวแทน: อินสแตนซ์ของโมเดลภาษาที่กำหนดค่าด้วยคำแนะนำและบทบาทเฉพาะ
- เครื่องมือ: ฟังก์ชันหรือบริการ (เช่น การค้นหาเว็บ โค้ด Python แบบกำหนดเอง) ที่ขยายขีดความสามารถของตัวแทน
- การส่งมอบ: กลไกที่ช่วยให้ตัวแทนสามารถมอบหมายงานให้กับตัวแทนอื่นได้อย่างราบรื่น
- Guardrails: เลเยอร์การตรวจสอบความถูกต้องเพื่อให้แน่ใจว่าอินพุตและเอาต์พุตตรงตามเกณฑ์ที่กำหนด
- การติดตาม: บันทึกการดำเนินการสำหรับการแก้ไขข้อบกพร่องและการวิเคราะห์ประสิทธิภาพ

คู่มือนี้ออกแบบมาสำหรับนักพัฒนาที่มีความเข้าใจพื้นฐานเกี่ยวกับ Python และการโต้ตอบ API โดยให้คำอธิบายโดยละเอียด ตัวอย่างโค้ด และแนวทางปฏิบัติที่ดีที่สุดในการสร้างทรัพยากรที่แข็งแกร่งและครอบคลุม
การติดตั้งและการกำหนดค่า
การตั้งค่าที่เหมาะสมมีความสำคัญอย่างยิ่งต่อการใช้ OpenAI Agents SDK อย่างมีประสิทธิภาพ ส่วนนี้ครอบคลุมข้อกำหนดเบื้องต้น การตั้งค่าสภาพแวดล้อม การติดตั้ง และการตรวจสอบ
ข้อกำหนดเบื้องต้น
ก่อนดำเนินการ ตรวจสอบให้แน่ใจว่ามีสิ่งต่อไปนี้:
- Python 3.8+: ตรวจสอบเวอร์ชัน Python ของคุณด้วย
python --version
ติดตั้งจาก python.org หากจำเป็น

- OpenAI API Key: รับคีย์ของคุณจาก platform.openai.com ภายใต้การตั้งค่าบัญชีของคุณ คีย์นี้จะตรวจสอบสิทธิ์คำขอไปยังเซิร์ฟเวอร์ของ OpenAI

ขั้นตอนที่ 1: ตั้งค่าสภาพแวดล้อมเสมือน
สภาพแวดล้อมเสมือนจะแยกการพึ่งพาโครงการ ป้องกันความขัดแย้งกับโครงการ Python อื่นๆ ในการสร้างและเปิดใช้งาน:
- Linux/macOS:
python -m venv agents_env
source agents_env/bin/activate
- Windows:
python -m venv agents_env
agents_env\Scripts\activate
เมื่อเปิดใช้งานแล้ว พร้อมท์เทอร์มินัลของคุณควรสะท้อนถึงสภาพแวดล้อม (เช่น (agents_env)
) ขั้นตอนนี้เป็นแนวทางปฏิบัติที่ดีที่สุดสำหรับการพัฒนา Python เพื่อให้มั่นใจว่ามีพื้นที่ทำงานที่สะอาด
ขั้นตอนที่ 2: ติดตั้ง SDK
เมื่อสภาพแวดล้อมเสมือนทำงานอยู่ ให้ติดตั้ง SDK โดยใช้ pip:
pip install openai-agents
คำสั่งนี้จะดึงข้อมูล SDK เวอร์ชันล่าสุดและการพึ่งพาจาก PyPI ในการยืนยันการติดตั้ง ให้รัน:
pip show openai-agents-python
ซึ่งจะแสดงข้อมูลเมตา รวมถึงหมายเลขเวอร์ชัน ยืนยันว่ามีการติดตั้งแพ็คเกจ
ขั้นตอนที่ 3: กำหนดค่า API Key
SDK ต้องใช้ OpenAI API key เพื่อทำงาน ตั้งค่าเป็นตัวแปรสภาพแวดล้อมเพื่อหลีกเลี่ยงการฝังไว้ในโค้ดของคุณ ซึ่งช่วยเพิ่มความปลอดภัย:
- Linux/macOS:
export OPENAI_API_KEY='your-api-key'
- Windows:
set OPENAI_API_KEY='your-api-key'
ในการทำให้สิ่งนี้คงอยู่ตลอดเซสชัน ให้เพิ่มคำสั่งลงในไฟล์การกำหนดค่าเชลล์ของคุณ (เช่น .bashrc
หรือ .zshrc
บนระบบ Unix) หรือคุณสามารถตั้งค่าแบบเป็นโปรแกรมใน Python ได้ แม้ว่าสิ่งนี้จะมีความปลอดภัยน้อยกว่า:
import os
os.environ["OPENAI_API_KEY"] = "your-api-key"
ขั้นตอนที่ 4: ตรวจสอบการติดตั้ง
ทดสอบการตั้งค่าด้วยตัวแทนขั้นต่ำเพื่อให้แน่ใจว่าทุกอย่างทำงาน:
from agents import Agent, Runner
agent = Agent(name="TestAgent", instructions="Return 'Setup successful'")
result = Runner.run_sync(agent, "Run test")
print(result.final_output) # Expected output: "Setup successful"
หากสิ่งนี้พิมพ์ "Setup successful" การติดตั้งของคุณใช้งานได้ ปัญหาทั่วไป ได้แก่:
- Invalid API Key: ตรวจสอบคีย์อีกครั้งและตรวจสอบให้แน่ใจว่าไม่มีช่องว่างหรือการพิมพ์ผิดเพิ่มเติม
- Network Errors: ตรวจสอบการเชื่อมต่ออินเทอร์เน็ตและสถานะเซิร์ฟเวอร์ของ OpenAI
การสร้างตัวแทน
ตัวแทนเป็นส่วนประกอบพื้นฐานของ SDK โดยแต่ละตัวแทนจะถูกกำหนดโดยบทบาทและพฤติกรรมที่ไม่ซ้ำกัน
การเริ่มต้นตัวแทน
คลาส Agent
ใช้เพื่อสร้างตัวแทน พารามิเตอร์หลัก ได้แก่:
name
: ตัวระบุสตริง (เช่น "MathAgent")instructions
: สตริงที่ระบุวัตถุประสงค์ของตัวแทน (เช่น "แก้ปัญหาทางคณิตศาสตร์")model
: โมเดล OpenAI ที่จะใช้ (ค่าเริ่มต้น:gpt-4
)temperature
: จำนวนทศนิยมระหว่าง 0 ถึง 1 ที่ควบคุมความสุ่มของเอาต์พุต (ค่าเริ่มต้น: 0.7)
ตัวอย่าง: ตัวแทนพื้นฐาน
นี่คือตัวแทนง่ายๆ สำหรับเลขคณิต:
from agents import Agent, Runner
agent = Agent(
name="MathAgent",
instructions="Solve arithmetic expressions."
)
result = Runner.run_sync(agent, "Calculate 10 * 2")
print(result.final_output) # Output: "20"
เมธอด Runner.run_sync
จะดำเนินการตัวแทนพร้อมกัน โดยส่งคืนอ็อบเจกต์ผลลัพธ์พร้อมแอตทริบิวต์ final_output
การกำหนดค่าขั้นสูง
ปรับแต่งตัวแทนสำหรับความต้องการเฉพาะโดยการปรับพารามิเตอร์:
agent = Agent(
name="CreativeWriter",
instructions="Write a short story based on the prompt.",
model="gpt-4",
temperature=0.9
)
result = Runner.run_sync(agent, "A robot in a distant galaxy")
print(result.final_output) # Output: A creative story
- Model:
gpt-4
ให้เหตุผลที่เหนือกว่า ในขณะที่gpt-3.5-turbo
นั้นเร็วกว่าและถูกกว่าสำหรับงานที่ง่ายกว่า - Temperature: ค่าที่ต่ำกว่า (เช่น 0.2) จะให้เอาต์พุตที่คาดเดาได้ ค่าที่สูงกว่า (เช่น 0.9) จะเพิ่มความคิดสร้างสรรค์
ตัวอย่างตัวแทนหลายตัว
สร้างตัวแทนที่แตกต่างกันสำหรับงานต่างๆ:
support_agent = Agent(
name="SupportBot",
instructions="Answer technical support questions."
)
code_agent = Agent(
name="CodeHelper",
instructions="Generate Python code snippets."
)
support_result = Runner.run_sync(support_agent, "How do I install Python?")
code_result = Runner.run_sync(code_agent, "Write a function to add two numbers")
print(support_result.final_output) # Output: Installation instructions
print(code_result.final_output) # Output: "def add(a, b): return a + b"
ซึ่งแสดงให้เห็นถึงความยืดหยุ่นของ SDK ในการจัดการบทบาทที่หลากหลาย
การผสานรวมเครื่องมือ
เครื่องมือช่วยเพิ่มประสิทธิภาพตัวแทนโดยทำให้พวกเขาสามารถดำเนินการภายนอกได้ SDK รองรับเครื่องมือที่โฮสต์ เครื่องมือฟังก์ชันแบบกำหนดเอง และเครื่องมือที่ใช้ตัวแทน
การใช้เครื่องมือที่โฮสต์
เครื่องมือที่โฮสต์ เช่น web_search
ได้รับการสร้างไว้ล่วงหน้าและพร้อมใช้งาน:
from agents import Agent, Runner, web_search
agent = Agent(
name="ResearchAgent",
instructions="Answer questions using web search.",
tools=[web_search]
)
result = Runner.run_sync(agent, "What is the capital of France?")
print(result.final_output) # Output: "The capital of France is Paris."
ตัวแทนจะเรียกใช้ web_search
โดยอัตโนมัติเพื่อดึงข้อมูลแบบเรียลไทม์
การสร้างเครื่องมือฟังก์ชันแบบกำหนดเอง
กำหนดเครื่องมือแบบกำหนดเองด้วยตัวตกแต่ง @function_tool
เครื่องมือต้องยอมรับและส่งคืนสตริง
ตัวอย่าง: เครื่องมือดึงข้อมูล
from agents import Agent, Runner, function_tool
@function_tool
def fetch_data(id: str) -> str:
"""Return data for the given ID."""
# Simulated database lookup
return f"Data for ID {id}: active"
agent = Agent(
name="DataAgent",
instructions="Retrieve data using the tool.",
tools=[fetch_data]
)
result = Runner.run_sync(agent, "Fetch data for ID 123")
print(result.final_output) # Output: "Data for ID 123: active"
การผสานรวม APIs ภายนอก
เครื่องมือสามารถเชื่อมต่อกับบริการภายนอกได้ นี่คือตัวอย่างเครื่องมือสภาพอากาศ:
import requests
from agents import function_tool, Agent, Runner
@function_tool
def get_weather(city: str) -> str:
"""Get the current weather for a city."""
api_key = "your-weather-api-key" # Replace with a real key
url = f"http://api.weatherapi.com/v1/current.json?key={api_key}&q={city}"
response = requests.get(url)
if response.status_code == 200:
data = response.json()
return f"The weather in {city} is {data['current']['condition']['text']}."
return "Weather data unavailable."
agent = Agent(
name="WeatherAgent",
instructions="Provide weather updates using the tool.",
tools=[get_weather]
)
result = Runner.run_sync(agent, "What's the weather in Tokyo?")
print(result.final_output) # Output: "The weather in Tokyo is Sunny." (example)
ลงทะเบียนเพื่อรับ API key ฟรีที่ weatherapi.com เพื่อทดสอบสิ่งนี้

การรวมเครื่องมือหลายรายการ
ตัวแทนสามารถใช้เครื่องมือหลายรายการพร้อมกันได้:
@function_tool
def log_entry(text: str) -> str:
"""Log a message."""
return f"Logged: {text}"
agent = Agent(
name="MultiToolAgent",
instructions="Use tools to search and log.",
tools=[web_search, log_entry]
)
result = Runner.run_sync(agent, "Search for AI trends and log the query")
print(result.final_output) # Output includes search results and log confirmation
การส่งมอบตัวแทน
การส่งมอบช่วยให้ตัวแทนสามารถมอบหมายงานได้ ทำให้เวิร์กโฟลว์มีความซับซ้อน
การตั้งค่าการส่งมอบ
กำหนดตัวแทนหลักพร้อมการเข้าถึงตัวแทนรองผ่านพารามิเตอร์ handoffs
:
from agents import Agent, Runner
english_agent = Agent(
name="EnglishHelper",
instructions="Respond in English only."
)
spanish_agent = Agent(
name="SpanishHelper",
instructions="Respond in Spanish only."
)
triage_agent = Agent(
name="LanguageRouter",
instructions="Detect the language and hand off to the appropriate agent.",
handoffs=[english_agent, spanish_agent]
)
result = Runner.run_sync(triage_agent, "Hola, ¿qué tal?")
print(result.final_output) # Output: "¡Bien, gracias!" (or similar)
triage_agent
วิเคราะห์อินพุตและมอบหมายให้กับตัวแทนเฉพาะภาษาที่เหมาะสม
ตรรกะการส่งมอบ
การตัดสินใจส่งมอบขึ้นอยู่กับคำแนะนำของตัวแทนหลัก ตัวอย่างเช่น:
- "หากอินพุตมีคำภาษาสเปน ให้ส่งมอบให้กับ SpanishHelper"
- "สำหรับอินพุตภาษาอังกฤษ ให้ใช้ EnglishHelper"
ทดสอบด้วยอินพุตภาษาอังกฤษ:
result = Runner.run_sync(triage_agent, "How are you?")
print(result.final_output) # Output: "I'm good, thanks!"
การส่งมอบแบบซ้อน
สำหรับเวิร์กโฟลว์ที่ลึกกว่า ตัวแทนสามารถส่งมอบให้กับตัวแทนอื่นพร้อมการส่งมอบ:
analysis_agent = Agent(
name="AnalysisBot",
instructions="Analyze data and hand off for reporting."
)
report_agent = Agent(
name="ReportBot",
instructions="Generate a report from analysis."
)
main_agent = Agent(
name="WorkflowManager",
instructions="Start with analysis.",
handoffs=[analysis_agent, report_agent]
)
result = Runner.run_sync(main_agent, "Analyze sales data")
print(result.final_output) # Output: A generated report
การใช้งาน Guardrails
Guardrails บังคับใช้ข้อจำกัดเกี่ยวกับอินพุตและเอาต์พุตโดยใช้โมเดล Pydantic
การกำหนด Guardrail
สร้างแบบจำลองเพื่อตรวจสอบความถูกต้องของโครงสร้างเอาต์พุต:
from pydantic import BaseModel
from agents import Agent, Runner
class QuestionCheck(BaseModel):
is_question: bool
reason: str
guard_agent = Agent(
name="QuestionGuard",
instructions="Determine if the input is a question.",
output_type=QuestionCheck
)
result = Runner.run_sync(guard_agent, "What is the capital of France?")
print(result.final_output) # Output: {"is_question": true, "reason": "Ends with a question mark"}
การผสานรวมเวิร์กโฟลว์
ใช้ guardrails เพื่อกรองอินพุต:
task_agent = Agent(
name="TaskProcessor",
instructions="Process questions only.",
handoffs=[guard_agent]
)
result = Runner.run_sync(task_agent, "Tell me a story")
print(result.final_output) # Output indicates it’s not a question
การติดตามและการแก้ไขข้อบกพร่อง
การติดตามจะบันทึกรายละเอียดการดำเนินการของตัวแทน ซึ่งเข้าถึงได้ผ่าน OpenAI Dashboard
การเปิดใช้งานการติดตาม
การติดตามเป็นไปโดยอัตโนมัติ การรันแต่ละครั้งจะสร้างร่องรอยพร้อม:
- ข้อมูลอินพุต/เอาต์พุต
- การเรียกใช้เครื่องมือ
- กิจกรรมการส่งมอบ
- ข้อผิดพลาด
ตัวอย่างการแก้ไขข้อบกพร่อง
หากตัวแทนล้มเหลว ให้ตรวจสอบร่องรอยเพื่อระบุ:
- พารามิเตอร์เครื่องมือที่ไม่ถูกต้อง
- การส่งมอบเส้นทางที่ไม่ถูกต้อง
- ข้อผิดพลาด API
แนวทางปฏิบัติที่ดีที่สุด
การเพิ่มประสิทธิภาพ
- Model Choice: ใช้
gpt-3.5-turbo
เพื่อความเร็วgpt-4
สำหรับการให้เหตุผลที่ซับซ้อน - Temperature: 0.2 เพื่อความแม่นยำ 0.9 เพื่อความคิดสร้างสรรค์
- Async Execution: ใช้
Runner.run_async
สำหรับงานแบบขนาน
การจัดการข้อผิดพลาด
- Tools: ส่งคืนข้อความแสดงข้อผิดพลาดที่ชัดเจน (เช่น "Invalid ID")
- Handoffs: รวมตัวแทนสำรองสำหรับความล้มเหลว
การออกแบบเวิร์กโฟลว์
- Modularity: แบ่งงานระหว่างตัวแทน
- Clarity: เขียนคำแนะนำที่ไม่คลุมเครือ
- Validation: ใช้ guardrails ในขั้นตอนสำคัญ
บทสรุป
OpenAI Agents SDK ช่วยให้นักพัฒนาสามารถสร้างระบบ AI ที่ซับซ้อนด้วยตัวแทนเฉพาะทาง เครื่องมือแบบบูรณาการ และเวิร์กโฟลว์การทำงานร่วมกัน คู่มือนี้ให้รากฐานทางเทคนิคในการใช้ประโยชน์จากศักยภาพทั้งหมด พร้อมตัวอย่างและแนวทางปฏิบัติที่ดีที่สุด
แล้วอะไรต่อไป เริ่มทดลอง! เล่นกับคำแนะนำ เครื่องมือ และเวิร์กโฟลว์ต่างๆ และหากคุณติดขัด เครื่องมือต่างๆ เช่น Apidog สามารถช่วยในการทดสอบ API ได้ฟรี
