คุณอาจเคยได้ยินเกี่ยวกับนวัตกรรมล่าสุดของ OpenAI เครื่องมือใหม่สำหรับการสร้างตัวแทน (agents) เครื่องมือเหล่านี้ขับเคลื่อนโดย OpenAI API กำลังปฏิวัติวิธีการที่นักพัฒนาสร้างระบบอัจฉริยะที่ตอบสนองได้ ไม่ว่าคุณจะเป็นนักเขียนโค้ดที่มีประสบการณ์หรือเพิ่งเริ่มต้น โพสต์บล็อกนี้จะแนะนำคุณตลอดทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับการใช้ประโยชน์จากข้อเสนอของ OpenAI เพื่อสร้างตัวแทนของคุณเอง
ทำไมเครื่องมือใหม่ของ OpenAI สำหรับการสร้างตัวแทนจึงเป็นตัวเปลี่ยนเกม
OpenAI ได้ประกาศการรวมความสามารถในการค้นหาเว็บเข้ากับ OpenAI API การอัปเดตนี้แนะนำคำตอบที่รวดเร็วและทันสมัยพร้อมลิงก์ไปยังแหล่งข้อมูลบนเว็บที่เกี่ยวข้อง ทั้งหมดนี้ขับเคลื่อนโดยโมเดลเดียวกันที่อยู่เบื้องหลังการค้นหา ChatGPT เป็นก้าวกระโดดครั้งใหญ่สำหรับนักพัฒนาที่ต้องการสร้างระบบตัวแทน คิดว่าผู้ช่วย AI ที่สามารถจัดการงานที่ซับซ้อน ดึงข้อมูลแบบเรียลไทม์ และโต้ตอบกับผู้ใช้ได้อย่างราบรื่น
OpenAI ได้เปิดตัว Responses API, ความสามารถในการค้นหาเว็บ, เครื่องมือค้นหาไฟล์, คุณสมบัติการใช้คอมพิวเตอร์ และ Agents SDK พวกเขารวมกันเป็นกรอบงานที่แข็งแกร่งสำหรับการสร้างตัวแทนที่รู้สึกฉลาดขึ้นและเป็นอิสระมากขึ้นกว่าที่เคย เครื่องมือใหม่ได้รับการออกแบบมาเพื่อช่วยให้นักพัฒนาสร้างตัวแทนที่ปลอดภัย มีประสิทธิภาพ และทรงพลัง
ตัวแทนคืออะไรกันแน่? การทบทวนอย่างรวดเร็ว
ตัวแทน ในบริบทของ AI คือระบบหรือโปรแกรมอัตโนมัติที่สามารถรับรู้สภาพแวดล้อม ตัดสินใจ และดำเนินการเพื่อบรรลุเป้าหมายเฉพาะ คิดว่าพวกเขาเป็นเพื่อนร่วมทีมดิจิทัลของคุณที่สามารถตอบคำถาม ทำงาน หรือแม้แต่เรียนรู้จากการโต้ตอบ
เครื่องมือใหม่ของ OpenAI ช่วยให้นักพัฒนาสามารถสร้างตัวแทนเหล่านี้โดยใช้ OpenAI API ทำให้พวกเขาสมาร์ทขึ้น เร็วขึ้น และเชื่อมต่อกับเว็บมากขึ้น
เริ่มต้นใช้งาน: ทำความเข้าใจ Responses API ของ OpenAI
Responses API เป็นตัวเปลี่ยนเกมที่รวมคุณสมบัติที่ดีที่สุดของ Chat Completions และ Assistants APIs ของ OpenAI ไว้ในเครื่องมือที่ง่ายกว่าและมีประสิทธิภาพมากขึ้น หากคุณคุ้นเคยกับ API ก่อนหน้าของ OpenAI คุณจะเห็นคุณค่าว่าสิ่งนี้ช่วยปรับปรุงกระบวนการสร้างตัวแทนอย่างไร
ในการเริ่มต้น ให้ไปที่ เอกสารประกอบสำหรับนักพัฒนาของ OpenAI Responses API ช่วยให้คุณสามารถรวมเครื่องมือและโมเดลหลายรายการเพื่อดำเนินงานที่ซับซ้อน ทำให้เหมาะสำหรับการสร้างตัวแทน AI ที่สามารถจัดการทุกอย่างตั้งแต่การตอบคำถามไปจนถึงการจัดการเวิร์กโฟลว์หลายขั้นตอน
นี่คือวิธีที่คุณสามารถเริ่มต้นได้:
OpenAI API มีอินเทอร์เฟซที่เรียบง่ายสำหรับ AI models ที่ทันสมัยสำหรับการสร้างข้อความ การประมวลผลภาษาธรรมชาติ วิสัยทัศน์ของคอมพิวเตอร์ และอื่นๆ ตัวอย่างนี้สร้างเอาต์พุตข้อความจากพรอมต์ เช่นเดียวกับที่คุณอาจใช้ ChatGPT
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: "Write a one-sentence bedtime story about a unicorn."
});
console.log(response.output_text);วิเคราะห์อินพุตรูปภาพ
คุณสามารถให้ข้อมูลรูปภาพแก่โมเดลได้เช่นกัน สแกนใบเสร็จ วิเคราะห์ภาพหน้าจอ หรือค้นหาวัตถุในโลกแห่งความเป็นจริงด้วย วิสัยทัศน์ของคอมพิวเตอร์
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: [
{ role: "user", content: "What two teams are playing in this photo?" },
{
role: "user",
content: [
{
type: "input_image",
image_url: "https://upload.wikimedia.org/wikipedia/commons/3/3b/LeBron_James_Layup_%28Cleveland_vs_Brooklyn_2018%29.jpg",
}
],
},
],
});
console.log(response.output_text);ขยายโมเดลด้วยเครื่องมือ
ให้โมเดลเข้าถึงข้อมูลและความสามารถใหม่ๆ โดยใช้ เครื่องมือ คุณสามารถเรียกใช้ โค้ดที่กำหนดเอง ของคุณเอง หรือใช้ เครื่องมือในตัวที่ทรงพลัง ของ OpenAI ตัวอย่างนี้ใช้ การค้นหาเว็บ เพื่อให้โมเดลเข้าถึงข้อมูลล่าสุดบนอินเทอร์เน็ต
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
tools: [ { type: "web_search_preview" } ],
input: "What was a positive news story from today?",
});
console.log(response.output_text);มอบประสบการณ์ AI ที่รวดเร็ว
การใช้ Realtime API ใหม่ หรือ สตรีมมิงเหตุการณ์ ที่ส่งจากเซิร์ฟเวอร์ คุณสามารถสร้างประสบการณ์ที่มีประสิทธิภาพสูงและมีความหน่วงต่ำสำหรับผู้ใช้ของคุณ
import { OpenAI } from "openai";
const client = new OpenAI();
const stream = await client.responses.create({
model: "gpt-4o",
input: [
{
role: "user",
content: "Say 'double bubble bath' ten times fast.",
},
],
stream: true,
});
for await (const event of stream) {
console.log(event);
}สร้างตัวแทน
ใช้แพลตฟอร์ม OpenAI เพื่อสร้าง ตัวแทน ที่สามารถดำเนินการได้ เช่น ควบคุมคอมพิวเตอร์ ในนามของผู้ใช้ของคุณ ใช้ Agent SDK สำหรับ Python เพื่อสร้างตรรกะการประสานงานบนแบ็กเอนด์
from agents import Agent, Runner
import asyncio
spanish_agent = Agent(
name="Spanish agent",
instructions="You only speak Spanish.",
)
english_agent = Agent(
name="English agent",
instructions="You only speak English",
)
triage_agent = Agent(
name="Triage agent",
instructions="Handoff to the appropriate agent based on the language of the request.",
handoffs=[spanish_agent, english_agent],
)
async def main():
result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())
# ¡Hola! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás?เครื่องมือในตัวของ API ดำเนินการงานเหล่านี้ได้อย่างราบรื่น ช่วยประหยัดเวลาและความพยายามของคุณ นอกจากนี้ยังได้รับการออกแบบโดยคำนึงถึงความปลอดภัยและความน่าเชื่อถือ ซึ่งเป็นชัยชนะครั้งใหญ่สำหรับนักพัฒนา
การค้นหาเว็บสำหรับตัวแทนที่ฉลาดขึ้น
เครื่องมือค้นหาเว็บของ OpenAI ขับเคลื่อนโดยโมเดลต่างๆ เช่น การค้นหา GPT-4o และการค้นหา GPT-4o mini ช่วยให้ตัวแทนของคุณดึงข้อมูลล่าสุดจากอินเทอร์เน็ตและอ้างอิงแหล่งที่มา สิ่งนี้มีประโยชน์อย่างยิ่งสำหรับการสร้างตัวแทนที่จำเป็นต้องให้คำตอบที่ถูกต้องตามเวลาจริง
เครื่องมือค้นหาเว็บพร้อมใช้งานในการแสดงตัวอย่างผ่าน OpenAI API และมีความแม่นยำที่น่าประทับใจ ในเกณฑ์มาตรฐาน SimpleQA ของ OpenAI การค้นหา GPT-4o ทำคะแนนได้ 90% ในขณะที่การค้นหา GPT-4o mini ทำคะแนนได้ 88% นั่นคือความแม่นยำอย่างจริงจัง!
ในการใช้การค้นหาเว็บในตัวแทนของคุณ ให้ตรวจสอบ คู่มือของ OpenAI นี่คือสรุปโดยย่อ:
- รวมเครื่องมือ: ใช้ Responses API เพื่อเปิดใช้งานความสามารถในการค้นหาเว็บในตัวแทนของคุณ
- สร้างแบบสอบถาม: ออกแบบตัวแทนของคุณเพื่อส่งแบบสอบถามเฉพาะไปยังเครื่องมือค้นหาเว็บ ซึ่งจะดึงผลลัพธ์ที่เกี่ยวข้อง
- แสดงผลลัพธ์: ตัวแทนของคุณสามารถนำเสนอผลการค้นหาแก่ผู้ใช้ พร้อมด้วยลิงก์ไปยังแหล่งข้อมูลเพื่อความโปร่งใส
ลองนึกภาพการสร้างบอทบริการลูกค้าที่ใช้การค้นหาเว็บเพื่อตอบคำถามเกี่ยวกับการวางจำหน่ายผลิตภัณฑ์หรือแนวโน้มอุตสาหกรรม ด้วยการค้นหาเว็บของ OpenAI ตัวแทนของคุณสามารถส่งมอบคำตอบที่ทันท่วงทีและถูกต้อง เพิ่มความไว้วางใจและความพึงพอใจของผู้ใช้
การเรียนรู้การค้นหาไฟล์เพื่อการเข้าถึงข้อมูลที่มีประสิทธิภาพ
เครื่องมืออันทรงพลังอีกอย่างหนึ่งในคลังแสงของ OpenAI คือการค้นหาไฟล์ คุณสมบัตินี้ช่วยให้ตัวแทน AI ของคุณสามารถสแกนไฟล์ในฐานข้อมูลของบริษัทได้อย่างรวดเร็วเพื่อดึงข้อมูล เหมาะอย่างยิ่งสำหรับแอปพลิเคชันองค์กรที่ตัวแทนจำเป็นต้องเข้าถึงเอกสารภายใน รายงาน หรือชุดข้อมูล
OpenAI เน้นย้ำว่าจะไม่ฝึกอบรมโมเดลบนไฟล์เหล่านี้ เพื่อให้มั่นใจถึงความเป็นส่วนตัวและความปลอดภัย ซึ่งเป็นข้อพิจารณาที่สำคัญสำหรับธุรกิจ คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับการค้นหา ไฟล์ในเอกสารประกอบ
นี่คือวิธีรวมการค้นหาไฟล์เข้ากับตัวแทนของคุณ:
- อัปโหลดไฟล์: ใช้ OpenAI API เพื่ออัปโหลดไฟล์ของคุณไปยังแพลตฟอร์ม
- กำหนดค่าตัวแทน: ตั้งค่าตัวแทนของคุณเพื่อใช้เครื่องมือค้นหาไฟล์ภายใน Responses API
- สอบถามข้อมูล: ตัวแทนของคุณสามารถค้นหาข้อมูลเฉพาะภายในไฟล์และส่งคืนผลลัพธ์ที่เกี่ยวข้อง
ตัวอย่างเช่น คุณสามารถสร้างตัวแทน HR ที่ค้นหาบันทึกพนักงานเพื่อให้รายละเอียดเงินเดือนหรือยอดคงเหลือวันหยุด การทำงานอัตโนมัติในระดับนี้สามารถประหยัดเวลาในการทำงานด้วยตนเองหลายชั่วโมงและปรับปรุงประสิทธิภาพในทุกแผนก
การทำงานอัตโนมัติของงานด้วยความสามารถในการใช้คอมพิวเตอร์
โมเดล Computer-Using Agent (CUA) ของ OpenAI ซึ่งขับเคลื่อนผลิตภัณฑ์ Operator ช่วยให้ตัวแทนสามารถสร้างการกระทำของเมาส์และคีย์บอร์ด ซึ่งหมายความว่าตัวแทนของคุณสามารถทำงานอัตโนมัติ เช่น การป้อนข้อมูล เวิร์กโฟลว์ของแอป และการนำทางเว็บไซต์
เครื่องมือนี้อยู่ในตัวอย่างการวิจัยในปัจจุบัน แต่ก็แสดงให้เห็นถึงความหวังสำหรับนักพัฒนาแล้ว คุณสามารถสำรวจความสามารถได้ใน เอกสารประกอบ เวอร์ชันสำหรับผู้บริโภคของ CUA ซึ่งมีอยู่ใน Operator มุ่งเน้นไปที่การดำเนินการบนเว็บ แต่องค์กรสามารถเรียกใช้ได้ในเครื่องสำหรับการใช้งานที่กว้างขึ้น
นี่คือวิธีเริ่มต้น:
- เข้าถึงตัวอย่าง: ลงทะเบียนเพื่อดูตัวอย่างการวิจัยเพื่อทดสอบโมเดล CUA
- กำหนดงาน: ตั้งโปรแกรมตัวแทนของคุณให้ทำงานคอมพิวเตอร์เฉพาะ เช่น การกรอกแบบฟอร์มหรือคลิกปุ่ม
- ตรวจสอบประสิทธิภาพ: ใช้เครื่องมือของ OpenAI เพื่อแก้ไขข้อบกพร่องและปรับการกระทำของตัวแทนของคุณให้เหมาะสม
ลองนึกภาพการสร้างตัวแทนที่ทำงานอัตโนมัติของงานในสำนักงานที่ซ้ำๆ เช่น การอัปเดตสเปรดชีตหรือการจัดตารางการประชุม ด้วยความสามารถในการใช้คอมพิวเตอร์ ตัวแทนของคุณสามารถจัดการงานเหล่านี้ได้โดยอัตโนมัติ ทำให้พนักงานมนุษย์มีอิสระในการทำงานสร้างสรรค์มากขึ้น
1. ส่งคำขอไปยังโมเดล
ขั้นแรก คุณอาจต้องการตั้งค่าคีย์ OpenAI
import openai
import os
# Set API key
openai.api_key = os.environ.get("OPENAI_API_KEY")
ส่งคำขอเพื่อสร้าง Response ด้วยโมเดล computer-use-preview ที่ติดตั้งเครื่องมือ computer_use_preview คำขอนี้ควรรวมรายละเอียดเกี่ยวกับสภาพแวดล้อมของคุณ พร้อมกับพรอมต์เริ่มต้น
คุณสามารถใส่ภาพหน้าจอของสถานะเริ่มต้นของสภาพแวดล้อมได้ (ไม่จำเป็น)
เพื่อให้สามารถใช้เครื่องมือ computer_use_preview ได้ คุณต้องตั้งค่าพารามิเตอร์ truncation เป็น "auto" (โดยค่าเริ่มต้น การตัดทอนจะถูกปิดใช้งาน)
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="computer-use-preview",
tools=[{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser" # other possible values: "mac", "windows", "ubuntu"
}],
input=[
{
"role": "user",
"content": "Check the latest OpenAI news on bing.com."
}
# Optional: include a screenshot of the initial state of the environment
# {
# type: "input_image",
# image_url: f"data:image/png;base64,{screenshot_base64}"
# }
],
truncation="auto"
)
print(response.output)2. รับการดำเนินการที่แนะนำ
โมเดลจะส่งคืนเอาต์พุตที่มีรายการ computer_call ข้อความ หรือการเรียกเครื่องมืออื่นๆ ขึ้นอยู่กับสถานะของการสนทนา
ตัวอย่างของรายการ computer_call คือการคลิก การเลื่อน การกดปุ่ม หรือเหตุการณ์อื่นๆ ที่กำหนดไว้ใน การอ้างอิง API ในตัวอย่างของเรา รายการคือการดำเนินการคลิก:
"output": [
{
"type": "reasoning",
"id": "rs_67cc...",
"content": []
},
{
"type": "computer_call",
"id": "cu_67cc...",
"call_id": "call_zw3...",
"action": {
"type": "click",
"button": "left",
"x": 156,
"y": 50
},
"pending_safety_checks": [],
"status": "completed"
}
]โมเดลอาจส่งคืนรายการ reasoning ในเอาต์พุตการตอบสนองสำหรับการดำเนินการบางอย่าง หากเป็นเช่นนั้น คุณควรใส่รายการเหตุผลกลับมาเสมอเมื่อส่งคำขอถัดไปไปยังโมเดล CUA
รายการเหตุผลเข้ากันได้กับโมเดลเดียวกันที่สร้างขึ้นเท่านั้น หากคุณใช้โฟลว์ที่คุณใช้โมเดลหลายรายการที่มีประวัติการสนทนาเดียวกัน คุณควรกรองรายการเหตุผลเหล่านี้ออกจากอาร์เรย์อินพุตที่คุณส่งไปยังโมเดลอื่นๆ
3. ดำเนินการตามการกระทำในสภาพแวดล้อมของคุณ
ดำเนินการตามการกระทำที่เกี่ยวข้องบนคอมพิวเตอร์หรือเบราว์เซอร์ของคุณ วิธีที่คุณแมปการเรียกคอมพิวเตอร์ไปยังการกระทำผ่านโค้ดขึ้นอยู่กับสภาพแวดล้อมของคุณ โค้ดนี้แสดงการใช้งานตัวอย่างสำหรับการดำเนินการคอมพิวเตอร์ทั่วไป
def handle_model_action(page, action):
"""
Given a computer action (e.g., click, double_click, scroll, etc.),
execute the corresponding operation on the Playwright page.
"""
action_type = action.type
try:
match action_type:
case "click":
x, y = action.x, action.y
button = action.button
print(f"Action: click at ({x}, {y}) with button '{button}'")
# Not handling things like middle click, etc.
if button != "left" and button != "right":
button = "left"
page.mouse.click(x, y, button=button)
case "scroll":
x, y = action.x, action.y
scroll_x, scroll_y = action.scroll_x, action.scroll_y
print(f"Action: scroll at ({x}, {y}) with offsets (scroll_x={scroll_x}, scroll_y={scroll_y})")
page.mouse.move(x, y)
page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
case "keypress":
keys = action.keys
for k in keys:
print(f"Action: keypress '{k}'")
# A simple mapping for common keys; expand as needed.
if k.lower() == "enter":
page.keyboard.press("Enter")
elif k.lower() == "space":
page.keyboard.press(" ")
else:
page.keyboard.press(k)
case "type":
text = action.text
print(f"Action: type text: {text}")
page.keyboard.type(text)
case "wait":
print(f"Action: wait")
time.sleep(2)
case "screenshot":
# Nothing to do as screenshot is taken at each turn
print(f"Action: screenshot")
# Handle other actions here
case _:
print(f"Unrecognized action: {action}")
except Exception as e:
print(f"Error handling action {action}: {e}")4. จับภาพหน้าจอที่อัปเดต
หลังจากดำเนินการแล้ว ให้จับภาพสถานะที่อัปเดตของสภาพแวดล้อมเป็นภาพหน้าจอ ซึ่งแตกต่างกันไปขึ้นอยู่กับสภาพแวดล้อมของคุณ
def get_screenshot(page):
"""
Take a full-page screenshot using Playwright and return the image bytes.
"""
return page.screenshot()5. ทำซ้ำ
เมื่อคุณมีภาพหน้าจอแล้ว คุณสามารถส่งกลับไปยังโมเดลเป็น computer_call_output เพื่อรับการดำเนินการถัดไป ทำซ้ำขั้นตอนเหล่านี้ตราบเท่าที่คุณได้รับรายการ computer_call ในการตอบสนอง
import time
import base64
from openai import OpenAI
client = OpenAI()
def computer_use_loop(instance, response):
"""
Run the loop that executes computer actions until no 'computer_call' is found.
"""
while True:
computer_calls = [item for item in response.output if item.type == "computer_call"]
if not computer_calls:
print("No computer call found. Output from model:")
for item in response.output:
print(item)
break # Exit when no computer calls are issued.
# We expect at most one computer call per response.
computer_call = computer_calls[0]
last_call_id = computer_call.call_id
action = computer_call.action
# Execute the action (function defined in step 3)
handle_model_action(instance, action)
time.sleep(1) # Allow time for changes to take effect.
# Take a screenshot after the action (function defined in step 4)
screenshot_bytes = get_screenshot(instance)
screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
# Send the screenshot back as a computer_call_output
response = client.responses.create(
model="computer-use-preview",
previous_response_id=response.id,
tools=[
{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser"
}
],
input=[
{
"call_id": last_call_id,
"type": "computer_call_output",
"output": {
"type": "input_image",
"image_url": f"data:image/png;base64,{screenshot_base64}"
}
}
],
truncation="auto"
)
return responseการประสานงานตัวแทนด้วย Agents SDK
ชุดเครื่องมือโอเพนซอร์สของ OpenAI สำหรับการสร้างและจัดการเวิร์กโฟลว์แบบหลายตัวแทน SDK นี้สร้างขึ้นจากกรอบงาน Swarm ก่อนหน้านี้ของ OpenAI และนำเสนอเครื่องมือฟรีสำหรับนักพัฒนาในการรวมโมเดล ใช้มาตรการป้องกัน และตรวจสอบกิจกรรมของตัวแทน
Agents SDK เป็น Python-first และมีคุณสมบัติต่างๆ เช่น ลูปตัวแทนในตัวและการตรวจสอบความปลอดภัย เหมาะอย่างยิ่งสำหรับการสร้างระบบที่ซับซ้อนซึ่งตัวแทนหลายรายทำงานร่วมกันเพื่อแก้ปัญหา
วิธีใช้ Agents SDK:
- ดาวน์โหลด SDK: เข้าถึงโค้ดโอเพนซอร์สจาก ที่เก็บ GitHub ของ OpenAI
- ตั้งค่าเวิร์กโฟลว์แบบหลายตัวแทน: ใช้ SDK เพื่อประสานงานงานระหว่างตัวแทน มอบหมายตามความสามารถของพวกเขา
- เพิ่มมาตรการป้องกัน: ใช้การตรวจสอบความปลอดภัยเพื่อให้แน่ใจว่าตัวแทนของคุณทำงานอย่างมีความรับผิดชอบและเชื่อถือได้
ตัวอย่างเช่น คุณสามารถสร้างทีมขายของตัวแทน AI ที่ตัวแทนรายหนึ่งจัดการการค้นคว้าเว็บ อีกรายจัดการไฟล์ และรายที่สามทำงานอัตโนมัติของงานคอมพิวเตอร์ Agents SDK จะเชื่อมโยงเข้าด้วยกัน สร้างระบบที่ราบรื่นและมีประสิทธิภาพ
บทสรุป
จาก Responses API ไปจนถึงการค้นหาเว็บ การค้นหาไฟล์ การใช้คอมพิวเตอร์ และ Agents SDK OpenAI ได้ติดตั้งทุกสิ่งที่จำเป็นสำหรับนักพัฒนาในการสร้างระบบอัตโนมัติและชาญฉลาด ไม่ว่าคุณจะทำงานอัตโนมัติของงานทางธุรกิจ ปรับปรุงการบริการลูกค้า หรือสำรวจขอบเขตการวิจัยใหม่ๆ เครื่องมือเหล่านี้เปิดโลกแห่งความเป็นไปได้
แล้วคุณจะรออะไรอยู่? ดำดิ่งสู่ OpenAI API ทดลองใช้เครื่องมือใหม่ๆ และเริ่มสร้างตัวแทนที่ทำให้ผู้ใช้ของคุณประทับใจ และอย่าลืมดาวน์โหลด Apidog ได้ฟรีเพื่อปรับปรุงการพัฒนา API ของคุณและทำให้การเดินทางของคุณราบรื่นยิ่งขึ้น!
