ระบบตัวแทนอัตโนมัติด้วย AgentOps: ความสามารถในการสังเกตเห็นได้ การติดตาม และอื่น ๆ สำหรับการใช้งาน AI

การเติบโตของตัวแทนอัตโนมัติที่สร้างโดยโมเดลพื้นฐาน (FMs) เช่น โมเดลภาษาขนาดใหญ่ (LLMs) ได้เปลี่ยนแปลงวิธีการแก้ปัญหาที่ซับซ้อนและหลายขั้นตอน การใช้งานตัวแทนที่สามารถทำงานตั้งแต่การสนับสนุนลูกค้าไปจนถึงการวิศวกรรมซอฟต์แวร์ โดยการนำทางกระบวนการทำงานที่ซับซ้อนซึ่งรวมถึงการให้เหตุผล การใช้เครื่องมือ และหน่วยความจำ

อย่างไรก็ตาม เมื่อระบบเหล่านี้เติบโตในด้านความสามารถและความซับซ้อน ปัญหาเกี่ยวกับความสามารถในการสังเกตเห็นได้ ความน่าเชื่อถือ และการปฏิบัติตามกฎระเบียบก็เกิดขึ้น

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

อะไรคือ AgentOps?

AgentOps หมายถึงกระบวนการ ทools และเฟรมเวิร์กที่จำเป็นต่อการออกแบบ การใช้งาน การติดตาม และการปรับปรุงตัวแทนอัตโนมัติที่สร้างโดย FM ในการผลิต เป้าหมายของ AgentOps คือ:

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

ในแก่นแท้ AgentOps ขยายออกไปนอกเหนือจาก MLOps แบบดั้งเดิมโดยเน้นกระบวนการทำงานที่ซับซ้อนหลายขั้นตอน การผสมผสานเครื่องมือ และหน่วยความจำแบบปรับเปลี่ยนได้ ในขณะเดียวกันก็รักษาการติดตามและตรวจสอบอย่างเข้มงวด

ความท้าทายที่ AgentOps ช่วยแก้ไข

1. ความซับซ้อนของระบบตัวแทน

ตัวแทนอัตโนมัติทำงานในพื้นที่การกระทำที่กว้างขวาง ซึ่งต้องการการตัดสินใจที่แต่ละขั้นตอน ความซับซ้อนนี้ต้องการการวางแผนและกลไกการติดตามที่ซับซ้อน

2. ความต้องการความสามารถในการสังเกตเห็นได้

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

3. การแก้ปัญหาและการปรับปรุง

การระบุความผิดพลาดในกระบวนการทำงานหลายขั้นตอนหรือการประเมินผลลัพธ์ระหว่างกระบวนการทำงานเป็นเรื่องที่ท้าทายหากไม่มีการติดตามที่ละเอียด

4. การปรับขนาดและการจัดการต้นทุน

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

คุณลักษณะหลักของ AgentOps

1. การสร้างและปรับแต่งตัวแทน

นักพัฒนาสามารถกำหนดค่าตัวแทนโดยใช้เครื่องมือและเฟรมเวิร์กที่หลากหลาย:

• บทบาท: กำหนดความรับผิดชอบ (เช่น นักวิจัย ผู้วางแผน)
• การจำกัด: ตั้งค่าข้อจำกัดเพื่อให้แน่ใจว่ามีพฤติกรรมที่น่าเชื่อถือและเชื่อถือได้
• ชุดเครื่องมือ: อนุญาตให้ใช้งาน API ฐานข้อมูล หรือกราฟความรู้

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

2. ความสามารถในการสังเกตเห็นได้และการติดตาม

AgentOps บันทึกการดำเนินการที่ละเอียด:

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

เครื่องมือความสามารถในการสังเกตเห็นได้ เช่น Langfuse หรือ Arize ให้แผงควบคุมที่แสดงการบันทึกเหล่านี้ ช่วยให้ระบุจุดอ่อนหรือความผิดพลาด

3. การจัดการคำสั่ง

วิศวกรรมคำสั่งมีบทบาทสำคัญในการกำหนดพฤติกรรมของตัวแทน คุณลักษณะสำคัญรวมถึง:

• การควบคุมรุ่น: ติดตามการเปลี่ยนแปลงของคำสั่งเพื่อเปรียบเทียบประสิทธิภาพ
• การตรวจจับการฉีด: ระบุโค้ดที่เป็นอันตรายหรือข้อผิดพลาดในการนำเข้าคำสั่ง
• การปรับปรุง: เทคนิค เช่น Chain-of-Thought (CoT) หรือ Tree-of-Thought เพื่อปรับปรุงความสามารถในการให้เหตุผล

4. การผสมผสานข้อมูลรับกลับ

ข้อมูลรับกลับจากมนุษย์ยังคงมีความสำคัญอย่างยิ่งสำหรับการปรับปรุงอย่างต่อเนื่อง:

• ข้อมูลรับกลับแบบแสดงออก: ผู้ใช้ให้คะแนนผลลัพธ์หรือให้คำแนะนำ
• ข้อมูลรับกลับแบบไม่แสดงออก: เมตริก เช่น เวลาที่ใช้หรืออัตราการคลิกถูกวิเคราะห์เพื่อประเมินประสิทธิผล

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

5. การประเมินและการทดสอบ

แพลตฟอร์ม AgentOps สนับสนุนการทดสอบอย่างเข้มงวดทั่ว:

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

6. การผสมผสานหน่วยความจำและความรู้

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

7. การติดตามและการวัด

การตรวจสอบอย่างครอบคลุมติดตาม:

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

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

การจำแนกประเภทของข้อมูลที่สามารถติดตามได้

งานวิจัยนี้แนะนำการจำแนกประเภทที่เป็นระบบของข้อมูลที่เป็นพื้นฐานของความสามารถในการสังเกตเห็นได้ของ AgentOps:

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

การจำแนกประเภทนี้รับประกันความสอดคล้องและความชัดเจนในตลอดชีวิตของตัวแทน ทำให้การแก้ปัญหาและการปฏิบัติตามกฎระเบียบเป็นไปอย่างมีประสิทธิภาพ

การเดินผ่าน AgentOps (เครื่องมือ)

สิ่งนี้จะช่วยให้คุณตั้งค่าและใช้ AgentOps เพื่อติดตามและปรับปรุงตัวแทน AI ของคุณ

ขั้นตอนที่ 1: ติดตั้ง AgentOps SDK

ติดตั้ง AgentOps โดยใช้ 관리자แพ็คเกจ Python ที่คุณชอบ:

pip install agentops

ขั้นตอนที่ 2: เริ่มต้น AgentOps

นำเข้า AgentOps และเริ่มต้นด้วยคีย์ API ของคุณ เก็บคีย์ API ในไฟล์ .env สำหรับความปลอดภัย:

# เริ่มต้น AgentOps ด้วยคีย์ API
import agentops
import os
from dotenv import load_dotenv

<p># โหลดตัวแปรสิ่งแวดล้อม
load_dotenv()
AGENTOPS_API_KEY = os.getenv(&quot;AGENTOPS_API_KEY&quot;)</p>

<p># เริ่มต้นクライเอ็นต์ AgentOps
agentops.init(api_key=AGENTOPS_API_KEY, default_tags=[&quot;my-first-agent&quot;])</p>

ขั้นตอนนี้ตั้งค่าความสามารถในการสังเกตเห็นได้สำหรับการโต้ตอบ LLM ทั้งหมดในแอปพลิเคชันของคุณ

ขั้นตอนที่ 3: บันทึกการดำเนินงานด้วยตัวตกแต่ง

คุณสามารถติดเครื่องมือฟังก์ชันเฉพาะโดยใช้ตัวตกแต่ง @record_action ซึ่งจะบันทึกพารามิเตอร์ เวลาในการดำเนินการ และผลลัพธ์ ตัวอย่างเช่น:

from agentops import record_action

<p>@record_action(&quot;custom-action-tracker&quot;)
def is_prime(number):
&quot;&quot;&quot;ตรวจสอบว่าตัวเลขเป็นจำนวนเฉพาะหรือไม่&quot;&quot;&quot;
if number &amp;lt; 2:
return False
for i in range(2, int(number**0.5) + 1):
if number % i == 0:
return False
return True</p>

ฟังก์ชันนี้จะถูกบันทึกใน AgentOps Dashboard โดยให้เมตริกสำหรับเวลาในการดำเนินการและการติดตามข้อมูลเข้า/ออก

ขั้นตอนที่ 4: ติดตามตัวแทนแบบชื่อ

หากคุณใช้ตัวแทนแบบชื่อ ใช้ตัวตกแต่ง @track_agent เพื่อเชื่อมโยงทุกการดำเนินการและเหตุการณ์กับตัวแทนเฉพาะ

from agentops import track_agent

<p>@track_agent(name=&quot;math-agent&quot;)
class MathAgent:
def __init__(self, name):
self.name = name</p>

<p>def factorial(self, n):
&quot;&quot;&quot;คำนวณแฟคทอเรียลแบบเรียกซ้ำ&quot;&quot;&quot;
return 1 if n == 0 else n * self.factorial(n - 1)</p>

การดำเนินการใดๆ ภายในตัวแทนจะถูกบันทึกใน AgentOps Dashboard ภายใต้แท็ก “math-agent”

ขั้นตอนที่ 5: การสนับสนุนตัวแทนหลายตัว

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

@track_agent(name="qa-agent")
class QAAgent:
def generate_response(self, prompt):
return f"ตอบกลับ: {prompt}"

<p>@track_agent(name=&quot;developer-agent&quot;)
class DeveloperAgent:
def generate_code(self, task_description):
return f&quot;# โค้ดเพื่อ: {task_description}&quot;</p>

<p>qa_agent = QAAgent()
developer_agent = DeveloperAgent()</p>

<p>response = qa_agent.generate_response(&quot;อธิบายความสามารถในการสังเกตเห็นได้ใน AI.&quot;)
code = developer_agent.generate_code(&quot;คำนวณลำดับ Fibonacci&quot;)</p>

ทุกการเรียกจะปรากฏใน AgentOps Dashboard ภายใต้การบันทึกของตัวแทนแต่ละตัว

ขั้นตอนที่ 6: สิ้นสุดเซสชัน

ในการส่งสัญญาณสิ้นสุดเซสชัน ใช้เมธอด end_session:

# สิ้นสุดเซสชัน
agentops.end_session(state="Success", reason="เสร็จสิ้นกระบวนการ")

สิ่งนี้รับประกันว่าทุกข้อมูลจะถูกบันทึกและสามารถเข้าถึงได้ใน AgentOps Dashboard

ขั้นตอนที่ 7: การแสดงผลใน AgentOps Dashboard

เยี่ยมชม AgentOps Dashboard เพื่อสำรวจ:

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

ตัวอย่างที่ดีขึ้น: การตรวจจับความคิดแบบเรียกซ้ำ

AgentOps ยังสนับสนุนการตรวจจับวงจรการเรียกซ้ำในกระบวนการทำงานของตัวแทน มาทำให้ตัวอย่างก่อนหน้านี้ดีขึ้นด้วยการตรวจจับการเรียกซ้ำ:

@track_agent(name="recursive-agent")
class RecursiveAgent:
def solve(self, task, depth=0, max_depth=5):
"""จำลองการแก้ปัญหาแบบเรียกซ้ำด้วยการควบคุมความลึก"""
if depth >= max_depth:
return f"ถึงความลึกการเรียกซ้ำสูงสุดสำหรับงาน: {task}"
return self.solve(task, depth + 1)

<p>recursive_agent = RecursiveAgent()
output = recursive_agent.solve(&quot;เพิ่มประสิทธิภาพฐานข้อมูล&quot;)
print(output)</p>