คู่มือการทำความเข้าใจ การสร้าง และการปรับให้เหมาะสมของตัวแทนเรียก API API รายการงาน version: 1.0.0 paths: /tasks: post: summary: เพิ่มงานใหม่ requestBody: required: true

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

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

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

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

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

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

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

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

หนึ่ง. คำจำกัดความหลัก:

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

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

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

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

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

สำหรับคำขอ “เฮ้ Siri สภาพอากาศวันนี้เป็นอย่างไร?” คำเรียก API ตัวอย่างอาจดูเหมือนนี้:

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

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

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

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

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

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

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

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

2. บทบาทของโพรโทคอลบริบทแบบจำลอง (MCP)

MCP เป็นตัวช่วยสำคัญสำหรับการใช้เครื่องมือที่เป็นมาตรฐานและแข็งแกร่งมากขึ้นโดย LLM มันให้โครงสร้างสำหรับการกำหนดวิธีที่โมเดลสามารถเชื่อมต่อกับเครื่องมือและแหล่งข้อมูลภายนอกได้อย่างไร

การทำให้ MCP มาตรฐานเป็นประโยชน์เพราะช่วยให้การรวมเครื่องมือที่หลากหลายได้ง่ายขึ้น มันส่งเสริมการนำคำจำกัดความเครื่องมือกลับมาใช้ใหม่ในตัวแทนหรือโมเดลที่แตกต่างกัน นอกจากนี้ยังเป็นแนวทางปฏิบัติที่ดีสำหรับทีมวิศวกรรมที่เริ่มต้นด้วยการกำหนด API ที่มีโครงสร้าง เช่น OpenAPI spec เครื่องมือเช่น Stainless.ai ได้รับการออกแบบมาเพื่อช่วยแปลงการกำหนด API เหล่านี้เป็นคอนฟิก MCP ทำให้กระบวนการของการทำให้ API “พร้อมสำหรับตัวแทน” ง่ายขึ้น

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

หก. ตัวอย่างเชิงภาพของกระบวนการทำงาน

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

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

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

openapi: 3.0.0

info:
application/json:

schema:

type: object

properties:

description:

type: string

responses:

‘201’:

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

get:

summary: รับงานทั้งหมด

responses:

‘200’:

description: รายการงาน

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

แปลงการกำหนด API เป็นคอนฟิก MCP โดยใช้เครื่องมือเช่น Stainless.ai ซึ่งอาจให้ผลลัพธ์:

ขั้นตอนที่ 3: ใช้งานตัวแทน

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

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

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

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

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

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