ผู้นำทางความคิด

คู่มือการทำความเข้าใจ การสร้าง และการปรับให้เหมาะสมของตัวแทน API

Rodrigo Ceballos Lentini
เพิ่ม Unite.AI ลงในแหล่งข้อมูลที่คุณต้องการบน Google
ประเด็นสำคัญการกำหนดมาตรฐานการเข้าถึง API ผ่าน Model Context Protocol…
ดูเพิ่มเติม
  • การกำหนดมาตรฐานการเข้าถึง API ผ่าน Model Context Protocol ช่วยให้การผสานรวมเครื่องมือของเอเจนต์มีความแข็งแกร่ง
  • ชุดข้อมูลที่คัดเลือกด้วยมือมีประสิทธิภาพเหนือกว่าข้อมูลสังเคราะห์สำหรับการทดสอบและปรับแต่งเอเจนต์อย่างน่าเชื่อถือ
  • การปรับแต่งพรอมต์อย่างเป็นระบบด้วยเฟรมเวิร์กอย่าง DSPy ช่วยเพิ่มประสิทธิภาพของเอเจนต์ได้อย่างมีนัยสำคัญ

บทบาทของปัญญาประดิษฐ์ (AI) ในบริษัทเทคโนโลยีกำลังพัฒนาอย่างรวดเร็ว โดยใช้กรณีการใช้งาน AI ที่พัฒนาจากการประมวลผลข้อมูลแบบพาสซีฟไปสู่ตัวแทน (agent) ที่สามารถดำเนินการได้ตามคำสั่ง ตามการสำรวจเกี่ยวกับการนำ AI ไปใช้ในระดับโลกที่จัดทำโดย Georgian และ NewtonX ในเดือนมีนาคม 2025 พบว่า 91% ของผู้บริหารด้านเทคนิคในบริษัทที่เติบโตและองค์กรใช้หรือวางแผนจะใช้ AI ตัวแทน

ตัวแทน API เป็นตัวอย่างหลักของการเปลี่ยนแปลงนี้ ตัวแทน API ใช้โมเดลภาษาขนาดใหญ่ (LLM) เพื่อโต้ตอบกับระบบซอฟต์แวร์ผ่าน Application Programming Interfaces (APIs)

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

บริษัทต่างๆ กำลังใช้ตัวแทน API ในหลายโดเมน รวมถึง:

  • แอปพลิเคชันสำหรับผู้บริโภค: ผู้ช่วยอย่าง Apple’s Siri หรือ Amazon’s Alexa ได้รับการออกแบบมาเพื่อทำให้การทำงานประจำวันง่ายขึ้น เช่น การควบคุมอุปกรณ์สมาร์ทโฮมและการจอง
  • เวิร์กโฟลว์ระดับองค์กร: องค์กรได้นำตัวแทน API ไปใช้เพื่อทำให้การทำงานซ้ำๆ อัตโนมัติ เช่น การดึงข้อมูลจาก CRM การสร้างรายงาน หรือการรวมข้อมูลจากระบบภายใน
  • การดึงข้อมูลและการวิเคราะห์: องค์กรใช้ตัวแทน API เพื่อทำให้การเข้าถึงชุดข้อมูลที่เป็นกรรมสิทธิ์ ทรัพยากรแบบสมัครสมาชิก และ API สาธารณะง่ายขึ้น เพื่อสร้างข้อมูลเชิงลึก

ในบทความนี้ ฉันจะใช้แนวทางด้านวิศวกรรมในการทำความเข้าใจ การสร้าง และการปรับให้เหมาะสมของตัวแทน API สิ่งเหล่านี้อ้างอิงจากงานวิจัยและพัฒนาที่ทำโดยห้องปฏิบัติการ AI ของ Georgian

คำถามที่กระตุ้นให้เกิดการวิจัยของห้องปฏิบัติการ AI ในเรื่องตัวแทน API คือ “หากองค์กรมี API อะไรคือวิธีที่มีประสิทธิภาพที่สุดในการสร้างตัวแทนให้สามารถเชื่อมต่อกับ API โดยใช้ภาษาธรรมชาติ?”

ฉันจะอธิบายว่าตัวแทน API ทำงานอย่างไร และวิธีการออกแบบและพัฒนาตัวแทนเหล่านี้ให้สำเร็จสิ้น สุดท้าย ฉันจะให้กระบวนการทำงานที่เป็นระบบซึ่งทีมวิศวกรรมสามารถใช้เพื่อนำตัวแทน API ไปใช้

I. คำจำกัดความหลัก

  • API หรือ Application Programming Interface: ชุดของกฎและโพรโทคอลที่ทำให้แอปพลิเคชันซอฟต์แวร์ต่างๆ สามารถสื่อสารและแลกเปลี่ยนข้อมูลกันได้
  • ตัวแทน (Agent): ระบบ AI ที่ออกแบบมาเพื่อรับรู้สภาพแวดล้อม ตัดสินใจ และดำเนินการเพื่อบรรลุเป้าหมายที่เฉพาะเจาะจง
  • ตัวแทน API (API-Calling Agent): ตัวแทน AI พิเศษที่แปลคำสั่งภาษาธรรมชาติเป็นคำสั่ง API ที่แม่นยำ
  • ตัวแทนสร้างโค้ด (Code Generating Agent): ระบบ AI ที่ช่วยในการพัฒนาซอฟต์แวร์โดยการเขียน แก้ไข และแก้บั๊กโค้ด แม้ว่าจะเกี่ยวข้อง แต่ฉันเน้นไปที่ตัวแทน API ที่เรียกใช้ API เป็นหลัก
  • MCP (Model Context Protocol): โพรโทคอลที่กำหนดวิธีการที่โมเดลภาษาขนาดใหญ่ (LLM) สามารถเชื่อมต่อกับเครื่องมือและแหล่งข้อมูลภายนอกได้

II. งานหลัก: แปลภาษาธรรมชาติเป็นคำสั่ง API

ฟังก์ชันหลักของตัวแทน API คือการแปลคำสั่งภาษาธรรมชาติของผู้ใช้และแปลงเป็นคำสั่ง API ที่แม่นยำ

กระบวนการนี้มักเกี่ยวข้องกับ:

  1. การรับรู้ความตั้งใจ (Intent Recognition): ทำความเข้าใจเป้าหมายของผู้ใช้ แม้ว่าจะแสดงออกมาอย่างไม่ชัดเจนก็ตาม
  2. การคัดเลือกเครื่องมือ (Tool Selection): ระบุจุดสิ้นสุด API ที่เหมาะสม (หรือ “เครื่องมือ”) จากชุดตัวเลือกที่มีอยู่ที่สามารถตอบสนองความตั้งใจได้
  3. การดึงพารามิเตอร์ (Parameter Extraction): ระบุและดึงพารามิเตอร์ที่จำเป็นสำหรับการเรียก API ที่เลือกจากคำสั่งภาษาธรรมชาติของผู้ใช้
  4. การดำเนินการและการสร้างคำตอบ (Execution and Response Generation): ดำเนินการเรียก API รับคำตอบ และสร้างคำตอบที่สอดคล้องกันหรือดำเนินการตามลำดับ

พิจารณาคำสั่งเช่น “เฮ้ Siri, สภาพอากาศวันนี้เป็นอย่างไร?” ตัวแทนจะต้องระบุความจำเป็นในการเรียก API สภาพอากาศ ระบุตำแหน่งปัจจุบันของผู้ใช้ (หรืออนุญาตให้ระบุตำแหน่ง) และสร้างคำสั่ง API เพื่อดึงข้อมูลสภาพอากาศ

ตัวอย่างการเรียก API อาจดูเหมือน:

GET /v1/weather?location=New%20York&units=metric

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

ตัวอย่างเช่น ตัวแทนจะต้อง “จำ” ส่วนก่อนหน้าของการสนทนาหรือผลลัพธ์การเรียก API ก่อนหน้าเพื่อแจ้งการดำเนินการปัจจุบัน การสูญเสียบริบทเป็นโหมดการล้มเหลวที่พบบ่อยหากไม่ได้รับการจัดการอย่างชัดเจน

III. การออกแบบวิธีแก้ปัญหา: ส่วนประกอบและโพรโทคอลหลัก

การสร้างตัวแทน API ที่มีประสิทธิภาพต้องใช้แนวทางด้านสถาปัตยกรรมที่มีโครงสร้าง

1. การกำหนด “เครื่องมือ” สำหรับตัวแทน

เพื่อให้ LLM ใช้ API ได้ ความสามารถของ API ต้องอธิบายให้ LLM เข้าใจได้

การกำหนดเครื่องมือที่มีประสิทธิภาพประกอบด้วย:

  • คำอธิบายภาษาธรรมชาติที่ชัดเจนเกี่ยวกับวัตถุประสงค์และฟังก์ชันของเครื่องมือ
  • การกำหนดพารามิเตอร์输入ที่แม่นยำ (ชื่อ, ประเภท, ความจำเป็น, และคำอธิบาย)
  • คำอธิบายเกี่ยวกับข้อมูลที่เครื่องมือคืนมา

2. บทบาทของ Model Context Protocol (MCP)

MCP เป็นตัวช่วยสำคัญในการใช้เครื่องมือที่เป็นมาตรฐานและแข็งแกร่งสำหรับ LLM

การทำให้ MCP มาตรฐานเป็นประโยชน์เพราะช่วยให้การรวมเครื่องมือที่หลากหลายง่ายขึ้น ส่งเสริมการนำคำจำกัดความเครื่องมือไปใช้ซ้ำในตัวแทนหรือโมเดลที่แตกต่างกัน

นอกจากนี้ยังเป็นแนวทางปฏิบัติที่ดีสำหรับทีมวิศวกรรมในการเริ่มต้นด้วยการกำหนด API ที่ชัดเจน เช่น OpenAPI

เครื่องมืออย่าง Stainless.ai ได้รับการออกแบบมาเพื่อช่วยแปลง OpenAPI สเปคให้เป็น MCP

3. แฟรมเวิร์กตัวแทนและการเลือกการนำไปใช้

มีแฟรมเวิร์กหลายตัวที่สามารถช่วยในการสร้างตัวแทนได้

รวมถึง:

  • Pydantic: แม้ว่าไม่ใช่แฟรมเวิร์กตัวแทนโดยเฉพาะ แต่ Pydantic มีประโยชน์ในการกำหนดโครงสร้างข้อมูลและรับประกันความปลอดภัยของประเภทสำหรับอินพุตและเอาต์พุตเครื่องมือ ซึ่งสำคัญสำหรับความน่าเชื่อถือ
  • LastMile’s mcp_agent: แฟรมเวิร์กนี้ได้รับการออกแบบมาเพื่อทำงานกับ MCP โดยเฉพาะ โดยให้โครงสร้างที่มีความคิดเห็นมากกว่าซึ่งสอดคล้องกับแนวทางปฏิบัติที่ดีในการสร้างตัวแทน
  • แฟรมเวิร์กภายใน: ยังเป็นเรื่องธรรมดาที่จะใช้ตัวแทน AI ที่สร้างโค้ด (โดยใช้เครื่องมืออย่าง Cursor หรือ Cline) เพื่อช่วยเขียนโค้ดสำหรับตัวแทน โครงสร้างเครื่องมือ และตรรกะโดยรอบ

IV. วิศวกรรมสำหรับความน่าเชื่อถือและประสิทธิภาพ

การรับประกันว่าตัวแทนจะเรียก API ได้อย่างน่าเชื่อถือและทำงานได้ดี ต้องการความพยายามด้านวิศวกรรมที่มุ่งเน้น

สองวิธีในการทำเช่นนี้คือ (1) การสร้างและตรวจสอบชุดข้อมูล และ (2) การปรับให้เหมาะสมคำสั่งและตรรกะ

1. การสร้างและตรวจสอบชุดข้อมูล

การฝึกอบรม (หากใช้), ทดสอบ และปรับให้เหมาะสมตัวแทนจำเป็นต้องมีชุดข้อมูลที่มีคุณภาพสูง

ชุดข้อมูลนี้ควรประกอบด้วยคำสั่งภาษาธรรมชาติที่เป็นตัวแทนและลำดับหรือผลลัพธ์การเรียก API ที่ต้องการ

  • การสร้างด้วยตนเอง: การสร้างชุดข้อมูลด้วยตนเองรับประกันความแม่นยำและความเกี่ยวข้องสูง แต่อาจใช้เวลานาน
  • การสร้างสังเคราะห์: การสร้างข้อมูลโดยโปรแกรมหรือโดยใช้ LLM สามารถปรับขนาดการสร้างชุดข้อมูล แต่มีความท้าทายที่สำคัญ

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

2. การปรับให้เหมาะสมคำสั่งและตรรกะ

ประสิทธิภาพของตัวแทน LLM ขึ้นอยู่กับคำสั่งที่ใช้ในการชี้นำการให้เหตุผลและการเลือกเครื่องมือ

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

V. เส้นทางที่แนะนำสำหรับตัวแทน API ที่มีประสิทธิภาพ

การสร้างตัวแทน API ที่มีประสิทธิภาพเป็นวิศวกรรมที่ต้องทำซ้ำ

ตามผลการวิจัยของห้องปฏิบัติการ AI ของ Georgian สามารถปรับปรุงผลลัพธ์ได้โดยใช้กระบวนการทำงานที่เป็นระบบ เช่น:

  1. เริ่มต้นด้วยการกำหนด API ที่ชัดเจน: เริ่มต้นด้วยการกำหนด OpenAPI ที่มีโครงสร้างสำหรับ API ที่ตัวแทนจะโต้ตอบ
  2. การทำให้การเข้าถึงเครื่องมือเป็นมาตรฐาน: แปลงสเปค OpenAPI ให้เป็น MCP เครื่องมืออย่าง Stainless.ai สามารถช่วยในการแปลงนี้ได้
  3. การนำตัวแทนไปใช้: เลือกแฟรมเวิร์กหรือแนวทางที่เหมาะสม
  4. การสร้างชุดข้อมูลสำหรับการประเมินคุณภาพ: สร้างหรือตรวจสอบชุดข้อมูลของคำสั่งและปฏิกิริยา API ที่คาดหวังอย่างรอบคอบ
  5. การปรับให้เหมาะสมคำสั่งและตรรกะของตัวแทน: ใช้แฟรมเวิร์กอย่าง DSPy เพื่อปรับปรุงคำสั่งและตรรกะภายในของตัวแทนโดยใช้ชุดข้อมูลเพื่อขับเคลื่อนการปรับปรุงความแม่นยำและความน่าเชื่อถือ

VI. ตัวอย่างการทำงานที่เป็นภาพ

ต่อไปนี้คือตัวอย่างที่ทำให้กระบวนการทำงานที่แนะนำสำหรับการสร้างตัวแทน API ง่ายขึ้น:

ขั้นตอนที่ 1: เริ่มต้นด้วยการกำหนด API ที่ชัดเจน

สมมติว่า API สำหรับการจัดการรายการงานที่เรียบง่ายที่กำหนดไว้ใน OpenAPI:

openapi: 3.0.0

info:

title: รายการงาน API

version: 1.0.0

paths:

/tasks:

post:

summary: เพิ่มงานใหม่

requestBody:

required: true

content:

application/json:

schema:

type: object

properties:

description:

type: string

responses:

‘201’:

description: งานสร้างเสร็จสิ้น

ขั้นตอนที่ 2: การทำให้การเข้าถึงเครื่องมือเป็นมาตรฐาน

แปลงสเปค OpenAPI ให้เป็น MCP โดยใช้เครื่องมืออย่าง Stainless.ai:

ตาราง:

เครื่องมือ | คำอธิบาย | พารามิเตอร์ข้อมูลเข้า | คำอธิบายผลลัพธ์

เพิ่มงาน | เพิ่มงานใหม่ในรายการงาน | `description` (สตริง, จำเป็น): คำอธิบายของงาน | ยืนยันการสร้างงาน

รับงาน | รับงานทั้งหมดจากรายการงาน | ไม่มี | รายการงานพร้อมคำอธิบาย

ขั้นตอนที่ 3: การนำตัวแทนไปใช้

โดยใช้ Pydantic สำหรับการสร้างแบบจำลองข้อมูล สร้างฟังก์ชันสอดคล้องกับเครื่องมือ MCP จากนั้นใช้ LLM เพื่อแปลคำสั่งภาษาธรรมชาติและเลือกเครื่องมือและพารามิเตอร์ที่เหมาะสม

ขั้นตอนที่ 4: การสร้างชุดข้อมูลสำหรับการประเมินคุณภาพ

สร้างชุดข้อมูล:

คำสั่ง | การเรียก API ที่คาดหวัง | ผลลัพธ์ที่คาดหวัง

“เพิ่ม ‘ซื้อของชำ’ ในรายการของฉัน” | `เพิ่มงาน` โดยมี `description` = “ซื้อของชำ” | ยืนยันการสร้างงาน

“อะไรอยู่ในรายการของฉัน?” | `รับงาน` | รายการงาน รวม “ซื้อของชำ”

ขั้นตอนที่ 5: การปรับให้เหมาะสมคำสั่งและตรรกะของตัวแทน

ใช้ DSPy เพื่อปรับปรุงคำสั่ง โดยเน้นไปที่คำสั่งที่ชัดเจน การเลือกเครื่องมือ และการดึงพารามิเตอร์โดยใช้ชุดข้อมูลที่สร้างขึ้นสำหรับการประเมินและปรับปรุง

โดยการรวมบล็อกการสร้างเหล่านี้ – จากการกำหนด API ที่มีโครงสร้างและโพรโทคอลเครื่องมือมาตรฐานไปจนถึงการปฏิบัติด้านข้อมูลอย่างเข้มงวดและการปรับให้เหมาะสมอย่างเป็นระบบ – ทีมวิศวกรรมสามารถสร้างตัวแทน API ที่เรียกใช้ได้ มีความน่าเชื่อถือ และสามารถบำรุงรักษาได้

โรดริโก เซบัลลอส เลนตินี เป็น หัวหน้าฝ่ายเทคนิค AI ใน ห้องปฏิบัติการ AI ของ Georgian ซึ่งเขาช่วยให้ บริษัท ในพอร์ตโฟลิโอบรรลุผลลัพธ์ที่เป็นรูปธรรมจากโครงการ AI เชิงสร้างสรรค์และ AI แบบเอเจนต์ โรดริโก จบการศึกษาระดับมหาบัณฑิตสาขา ระบบประสาทและการคำนวณ โดยมุ่งเน้นไปที่ คอมพิวเตอร์วิทัศน์ จาก ETH Zürich