วิธีใช้ OpenAI Agents SDK?

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

💡

ก่อนที่เราจะเริ่มใช้งาน นี่คือเคล็ดลับง่ายๆ: เนื่องจากเราจะทำงานกับ APIs จำนวนมากในคู่มือนี้ คุณอาจต้องการใช้ Apidog เป็นเครื่องมือฟรีที่ทำให้การทดสอบและการแก้ไขข้อบกพร่องของ APIs เป็นเรื่องง่าย เหมาะสำหรับการทดลองใช้ OpenAI Agents SDK คุณสามารถดาวน์โหลด Apidog ได้ฟรีที่นี่ เชื่อฉันเถอะ มันจะช่วยคุณประหยัดปัญหาในภายหลัง!

button

บทนำ

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 ได้ฟรี

button