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

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

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

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

AgentOps คืออะไร?

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

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

หัวใจหลักของ 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 การติดตาม และช่วงสำหรับการตรวจสอบแบบละเอียด

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

ตัวแทนOps (เครื่องมือ) แนวทางการใช้งาน

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

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

ติดตั้ง AgentOps โดยใช้ตัวจัดการแพ็คเกจ Python ที่คุณต้องการ:

pip install agentops

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

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

# Initialize AgentOps with API Key
import agentops
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()
AGENTOPS_API_KEY = os.getenv("AGENTOPS_API_KEY")

# Initialize the AgentOps client
agentops.init(api_key=AGENTOPS_API_KEY, default_tags=["my-first-agent"])

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

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

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

from agentops import record_action

@record_action("custom-action-tracker")
def is_prime(number):
    """Check if a number is prime."""
    if number < 2:
        return False
    for i in range(2, int(number**0.5) + 1):
        if number % i == 0:
            return False
    return True

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

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

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

from agentops import track_agent

@track_agent(name="math-agent")
class MathAgent:
    def __init__(self, name):
        self.name = name

    def factorial(self, n):
        """Calculate factorial recursively."""
        return 1 if n == 0 else n * self.factorial(n - 1)

การดำเนินการหรือการเรียก LLM ใดๆ ภายในตัวแทนนี้จะเชื่อมโยงกับ "math-agent" แท็ก

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

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

@track_agent(name="qa-agent")
class QAAgent:
    def generate_response(self, prompt):
        return f"Responding to: {prompt}"

@track_agent(name="developer-agent")
class DeveloperAgent:
    def generate_code(self, task_description):
        return f"# Code to perform: {task_description}"

qa_agent = QAAgent()
developer_agent = DeveloperAgent()

response = qa_agent.generate_response("Explain observability in AI.")
code = developer_agent.generate_code("calculate Fibonacci sequence")

การโทรแต่ละครั้งจะปรากฏบนแดชบอร์ด AgentOps ภายใต้การติดตามตัวแทนที่เกี่ยวข้อง

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

เพื่อส่งสัญญาณสิ้นสุดเซสชัน ให้ใช้ end_session วิธีการ โดยทางเลือกให้รวมสถานะเซสชัน (Success or Fail) และเหตุผล

# End of session
agentops.end_session(state="Success", reason="Completed workflow")

วิธีนี้จะช่วยให้แน่ใจว่าข้อมูลทั้งหมดได้รับการบันทึกและสามารถเข้าถึงได้ในแดชบอร์ด AgentOps

ขั้นตอนที่ 7: แสดงภาพในแผงควบคุม AgentOps

เยี่ยมชมร้านค้า แผงควบคุม AgentOps สำรวจ:

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

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

AgentOps ยังรองรับการตรวจจับลูปแบบเรียกซ้ำในเวิร์กโฟลว์ของตัวแทนอีกด้วย มาขยายตัวอย่างก่อนหน้าด้วยการตรวจจับแบบเรียกซ้ำ:

@track_agent(name="recursive-agent")
class RecursiveAgent:
    def solve(self, task, depth=0, max_depth=5):
        """Simulates recursive task solving with depth control."""
        if depth >= max_depth:
            return f"Max recursion depth reached for task: {task}"
        return self.solve(task, depth + 1)

recursive_agent = RecursiveAgent()
output = recursive_agent.solve("Optimize database queries")
print(output)