Agen Otonom dengan AgentOps: Observabilitas, Traceability, dan Dilanjutkan untuk Aplikasi AI Anda

Pertumbuhan agen otonom yang didukung oleh model dasar (FM) seperti Large Language Models (LLM) telah mengubah cara kita menyelesaikan masalah kompleks dan multi-langkah. Agen-agen ini melakukan tugas mulai dari dukungan pelanggan hingga rekayasa perangkat lunak, menavigasi alur kerja yang rumit yang menggabungkan penalaran, penggunaan alat, dan memori.

Namun, ketika sistem ini tumbuh dalam kemampuan dan kompleksitas, tantangan dalam observabilitas, keandalan, dan kepatuhan muncul.

Ini adalah tempat AgentOps masuk; sebuah konsep yang dimodelkan setelah DevOps dan MLOps tetapi dirancang khusus untuk mengelola siklus hidup agen berbasis FM.

Apa itu AgentOps?

AgentOps mengacu pada proses, alat, dan kerangka kerja yang diperlukan untuk merancang, mengirim, memantau, dan mengoptimalkan agen otonom berbasis FM di produksi. Tujuannya adalah:

• Observabilitas: Memberikan visibilitas penuh ke dalam proses eksekusi dan pengambilan keputusan agen.
• Traceability: Mengambil artefak rinci di seluruh siklus hidup agen untuk debugging, optimasi, dan kepatuhan.
• Keandalan: Memastikan output yang konsisten dan dapat dipercaya melalui pemantauan dan alur kerja yang kuat.

Pada intinya, AgentOps melampaui MLOps tradisional dengan menekankan alur kerja iteratif, multi-langkah, integrasi alat, dan memori adaptif, semuanya sambil mempertahankan pelacakan dan pemantauan yang ketat.

Tantangan Utama yang Ditangani oleh AgentOps

1. Kompleksitas Sistem Agen

Agen otonom memproses tugas di seluruh ruang aksi yang luas, memerlukan keputusan pada setiap langkah. Kompleksitas ini menuntut mekanisme perencanaan dan pemantauan yang canggih.

2. Persyaratan Observabilitas

Kasus penggunaan yang berisiko tinggi – seperti diagnosis medis atau analisis hukum – menuntut traceability yang granular. Kepatuhan dengan peraturan seperti Undang-Undang AI UE lebih lanjut menekankan kebutuhan akan kerangka kerja observabilitas yang kuat.

3. Debugging dan Optimasi

Mengidentifikasi kesalahan dalam alur kerja multi-langkah atau menilai output antara tanpa jejak rinci dari tindakan agen adalah tantangan.

4. Skalabilitas dan Manajemen Biaya

Mengirim agen ke produksi memerlukan pemantauan metrik seperti latensi, penggunaan token, dan biaya operasional untuk memastikan efisiensi tanpa mengompromikan kualitas.

Fitur Inti dari Platform AgentOps

1. Pembuatan dan Kustomisasi Agen

Pengembang dapat mengkonfigurasi agen menggunakan registri komponen:

• Peran: Definisikan tanggung jawab (misalnya, peneliti, perencana).
• Guardrails: Tetapkan batasan untuk memastikan perilaku yang etis dan dapat diandalkan.
• Toolkit: Aktifkan integrasi dengan API, database, atau grafik pengetahuan.

Agen dibangun untuk berinteraksi dengan dataset tertentu, alat, dan prompt sambil mempertahankan kepatuhan dengan aturan yang telah ditetapkan sebelumnya.

2. Observabilitas dan Pelacakan

AgentOps mengambil log eksekusi rinci:

• Jejak: Catat setiap langkah dalam alur kerja agen, dari panggilan LLM hingga penggunaan alat.
• Span: Bagi jejak menjadi langkah granular, seperti pengambilan, generasi embedding, atau invocation alat.
• Artefak: Lacak output antara, keadaan memori, dan template prompt untuk membantu debugging.

Alat observabilitas seperti Langfuse atau Arize menyediakan dasbor yang memvisualisasikan jejak ini, membantu mengidentifikasi bottleneck atau kesalahan.

3. Manajemen Prompt

Teknik rekayasa prompt memainkan peran penting dalam membentuk perilaku agen. Fitur kunci termasuk:

• Penomoran Versi: Lacak iterasi prompt untuk perbandingan kinerja.
• Deteksi Injeksi: Identifikasi kode berbahaya atau kesalahan input dalam prompt.
• Optimasi: Teknik seperti Chain-of-Thought (CoT) atau Tree-of-Thought meningkatkan kemampuan penalaran.

4. Integrasi Umpan Balik

Umpan balik manusia tetap penting untuk perbaikan iteratif:

• Umpan Balik Eksplisit: Pengguna menilai output atau memberikan komentar.
• Umpan Balik Implisit: Metrik seperti waktu pada tugas atau tingkat klik dianalisis untuk mengukur efektivitas.

Lingkaran umpan balik ini memperbaiki kinerja agen dan benchmark evaluasi yang digunakan untuk pengujian.

5. Evaluasi dan Pengujian

Platform AgentOps memfasilitasi pengujian yang ketat di seluruh:

• Benchmark: Bandingkan kinerja agen dengan standar industri.
• Evaluasi Langkah demi Langkah: Tinjau langkah-langkah intermediate dalam alur kerja untuk memastikan kebenaran.
• Evaluasi Trajektori: Validasi jalur pengambilan keputusan yang diambil oleh agen.

6. Integrasi Memori dan Pengetahuan

Agen menggunakan memori jangka pendek untuk konteks (misalnya, riwayat percakapan) dan memori jangka panjang untuk menyimpan wawasan dari tugas sebelumnya. Ini memungkinkan agen untuk beradaptasi secara dinamis sambil mempertahankan konsistensi seiring waktu.

7. Pemantauan dan Metrik

Pemantauan komprehensif melacak:

• Latensi: Ukur waktu respons untuk optimasi.
• Penggunaan Token: Pantau konsumsi sumber daya untuk mengontrol biaya.
• Metri Kualitas: Evaluasi relevansi, akurasi, dan toksisitas.

Metrik ini divisualisasikan di seluruh dimensi seperti sesi pengguna, prompt, dan alur kerja, memungkinkan intervensi waktu nyata.

Taksonomi Artefak yang Dapat Dilacak

Makalah ini memperkenalkan taksonomi sistematis dari artefak yang mendasari observabilitas AgentOps:

• Artefak Pembuatan Agen: Metadata tentang peran, tujuan, dan batasan.
• Artefak Eksekusi: Log panggilan alat, antrian sub-tugas, dan langkah penalaran.
• Artefak Evaluasi: Benchmark, lingkaran umpan balik, dan metrik skoring.
• Artefak Pelacakan: ID sesi, ID jejak, dan span untuk pemantauan granular.

Taksonomi ini memastikan konsistensi dan kejelasan di seluruh siklus hidup agen, membuat debugging dan kepatuhan lebih mudah.

AgentOps (alat) Walkthrough

Ini akan membimbing Anda melalui pengaturan dan penggunaan AgentOps untuk memantau dan mengoptimalkan agen AI Anda.

Langkah 1: Instal SDK AgentOps

Instal AgentOps menggunakan pengelola paket Python yang Anda preferensi:

pip install agentops

Langkah 2: Inisialisasi AgentOps

Pertama, impor AgentOps dan inisialisasi menggunakan kunci API Anda. Simpan kunci API dalam file .env untuk keamanan:

# Inisialisasi AgentOps dengan Kunci API
import agentops
import os
from dotenv import load_dotenv

<p># Muat variabel lingkungan
load_dotenv()
AGENTOPS_API_KEY = os.getenv(&quot;AGENTOPS_API_KEY&quot;)</p>

<p># Inisialisasi klien AgentOps
agentops.init(api_key=AGENTOPS_API_KEY, default_tags=[&quot;my-first-agent&quot;])</p>

Langkah ini mengatur observabilitas untuk semua interaksi LLM dalam aplikasi Anda.

Langkah 3: Rekam Tindakan dengan Dekorator

Anda dapat menginstrumentasi fungsi tertentu menggunakan dekorator @record_action, yang melacak parameter, waktu eksekusi, dan output. Berikut contoh:

from agentops import record_action

<p>@record_action(&quot;custom-action-tracker&quot;)
def is_prime(number):
&quot;&quot;&quot;Periksa apakah sebuah bilangan prima.&quot;&quot;&quot;
jika number &lt; 2:
return False
untuk i dalam range(2, int(number**0.5) + 1):
jika number % i == 0:
return False
return True</p>

Fungsi ini sekarang akan dicatat dalam dasbor AgentOps, menyediakan metrik untuk waktu eksekusi dan pelacakan input-output.

Langkah 4: Lacak Agen Bernama

Jika Anda menggunakan agen bernama, gunakan dekorator @track_agent untuk mengikat semua tindakan dan peristiwa ke agen tertentu.

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;Menghitung faktorial secara rekursif.&quot;&quot;&quot;
return 1 jika n == 0 lain n * self.factorial(n - 1)</p>

Semua tindakan atau panggilan LLM dalam agen ini sekarang dikaitkan dengan tag “math-agent”.

Langkah 5: Dukungan Multi-Agen

Untuk sistem yang menggunakan beberapa agen, Anda dapat melacak peristiwa di seluruh agen untuk observabilitas yang lebih baik. Berikut contoh:

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

<p>@track_agent(name=&quot;developer-agent&quot;)
class DeveloperAgent:
def generate_code(self, task_description):
return f&quot;# Kode untuk melakukan: {task_description}&quot;</p>

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

<p>response = qa_agent.generate_response(&quot;Jelaskan observabilitas dalam AI.&quot;)
code = developer_agent.generate_code(&quot;menghitung urutan Fibonacci&quot;)</p>

Setiap panggilan akan muncul dalam dasbor AgentOps di bawah jejak agen yang sesuai.

Langkah 6: Akhiri Sesi

Untuk menandai akhir sesi, gunakan metode end_session. Opsi, sertakan keadaan sesi (Sukses atau Gagal) dan alasan.

# Akhir sesi
agentops.end_session(state="Sukses", reason="Alur kerja selesai")

Ini memastikan semua data dicatat dan dapat diakses dalam dasbor AgentOps.

Langkah 7: Visualisasikan dalam Dasbor AgentOps

Kunjungi Dasbor AgentOps untuk menjelajahi:

• Replay Sesi: Jejak eksekusi langkah demi langkah.
• Analitik: Metrik biaya LLM, penggunaan token, dan latensi.
• Deteksi Kesalahan: Identifikasi dan debug kesalahan atau loop rekursif.

Contoh Ditingkatkan: Deteksi Pemikiran Rekursif

AgentOps juga mendukung deteksi loop rekursif dalam alur kerja agen. Mari kita perluas contoh sebelumnya dengan deteksi rekursif:

@track_agent(name="recursive-agent")
class RecursiveAgent:
def solve(self, task, depth=0, max_depth=5):
"""Mensimulasikan pemecahan tugas rekursif dengan kontrol kedalaman."""
jika depth >= max_depth:
return f"Kedalaman rekursif maksimum tercapai untuk tugas: {task}"
return self.solve(task, depth + 1)

<p>recursive_agent = RecursiveAgent()
output = recursive_agent.solve(&quot;Optimalkan kueri database&quot;)
print(output)</p>