Analisis Jejak dengan LangSmith dan Langfuse
Membaca jejak: mengidentifikasi alat yang lambat, keputusan yang keliru, dan pola kesalahan.
Analisis Jejak dengan LangSmith dan Langfuse adalah pelajaran AI Agents gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Agents, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Agents mencakup 4 pelajaran total.
Mengapa Agen Anda Perlu Dilacak
Agen melakukan beberapa pemanggilan LLM dan invokasi alat dalam setiap eksekusi. Tanpa pelacakan, proses debug hanya berdasarkan perkiraan. Pelacakan mencatat setiap langkah: masukan, keluaran, penggunaan token, latensi, dan kesalahan — sehingga Anda mendapatkan gambaran lengkap tentang setiap eksekusi.
Penyiapan LangSmith
LangSmith adalah platform pelacakan Anthropic untuk LangChain. Aktifkan dengan menetapkan dua variabel lingkungan. Setiap pemanggilan LangChain secara otomatis dilacak dan dapat dilihat di antarmuka LangSmith.
import os
from dotenv import load_dotenv
load_dotenv()
# LangSmith tracing configuration
os.environ['LANGCHAIN_TRACING_V2'] = 'true'
os.environ['LANGCHAIN_API_KEY'] = os.environ.get('LANGSMITH_API_KEY', 'ls__...')
os.environ['LANGCHAIN_PROJECT'] = 'my-agent-project'
# Now any LangChain code is automatically traced
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model='gpt-4o-mini', api_key=os.environ.get('OPENAI_API_KEY', 'sk-...'))
# This call is traced automatically
response = llm.invoke([HumanMessage(content='What is 2+2?')])
print(response.content)
# Check trace at: https://smith.langchain.comMenambahkan Metadata Eksekusi
Tambahkan label dan metadata ke jejak agar Anda dapat memfilter dan mencari di antarmuka LangSmith. Hal ini berguna untuk melacak berbagai versi agen, ID pengguna, atau label eksperimen.
import os
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
from langsmith import traceable
os.environ['LANGCHAIN_TRACING_V2'] = 'true'
os.environ['LANGCHAIN_API_KEY'] = 'ls__your-key'
os.environ['LANGCHAIN_PROJECT'] = 'my-agent-project'
llm = ChatOpenAI(model='gpt-4o-mini', api_key='sk-...')
@traceable(name='my-agent-run', tags=['production', 'v2'], metadata={'user_id': '42'})
def run_agent(question: str) -> str:
response = llm.invoke(
[HumanMessage(content=question)],
config={
'run_name': f'agent-{question[:20]}',
'tags': ['production'],
'metadata': {'user_id': '42', 'version': 'v2.1'}
}
)
return response.content
result = run_agent('Explain LangChain tracing')
print(result)Melihat Jejak di Antarmuka LangSmith
Di dasbor LangSmith, Anda dapat melihat setiap eksekusi beserta seluruh pohon jejaknya. Setiap simpul menampilkan: masukan, keluaran, jumlah token, latensi, dan semua kesalahan. Anda dapat membandingkan eksekusi dan memfilter berdasarkan label atau proyek.
- Filter berdasarkan status kesalahan untuk menemukan eksekusi yang gagal
- Urutkan berdasarkan latensi untuk mengidentifikasi langkah yang lambat
- Bandingkan dua eksekusi secara berdampingan untuk men-debug regresi
# Programmatically query LangSmith for run data
from langsmith import Client
client = Client(api_key='ls__your-key')
# List recent runs for a project
runs = list(client.list_runs(
project_name='my-agent-project',
execution_order=1, # Top-level runs only
error=True, # Only failed runs
limit=10
))
for run in runs:
print(f'Run: {run.name}')
print(f' Status: {run.status}')
print(f' Latency: {run.end_time - run.start_time if run.end_time else "running"}')
print(f' Error: {run.error}')
print()Langfuse untuk Pelacakan Kustom
Langfuse adalah alternatif sumber terbuka untuk LangSmith. Langfuse dapat bekerja dengan kerangka kerja LLM apa pun atau kode kustom. Gunakan SDK Langfuse untuk membuat jejak dan rentang secara manual.
from langfuse import Langfuse
lf = Langfuse(
public_key='pk-lf-...',
secret_key='sk-lf-...',
host='https://cloud.langfuse.com' # Or your self-hosted URL
)
# Create a trace
trace = lf.trace(
name='email-agent-run',
user_id='user-42',
metadata={'environment': 'production'}
)
# Create a span for entity extraction
span = trace.span(
name='entity-extraction',
input={'text': 'Meeting with Alice from Google tomorrow'}
)
# Simulate work
extracted = ['Alice', 'Google']
# End the span with output
span.end(output={'entities': extracted})
print('Trace created in Langfuse')
print(f'View at: https://cloud.langfuse.com/trace/{trace.id}')Melacak Pemanggilan LLM di Langfuse
Buat rentang generation untuk setiap pemanggilan LLM. Hal ini menangkap model yang digunakan, instruksi, hasil penyelesaian, dan jumlah token — data terpenting untuk analisis biaya.
from langfuse import Langfuse
import openai
lf = Langfuse(public_key='pk-lf-...', secret_key='sk-lf-...')
client = openai.OpenAI(api_key='sk-...')
def traced_llm_call(trace, prompt: str, model: str = 'gpt-4o-mini') -> str:
generation = trace.generation(
name='llm-call',
model=model,
input=[{'role': 'user', 'content': prompt}]
)
response = client.chat.completions.create(
model=model,
messages=[{'role': 'user', 'content': prompt}]
)
content = response.choices[0].message.content
generation.end(
output=content,
usage={
'prompt_tokens': response.usage.prompt_tokens,
'completion_tokens': response.usage.completion_tokens,
'total_tokens': response.usage.total_tokens
}
)
return content
trace = lf.trace(name='test-trace')
result = traced_llm_call(trace, 'What is the capital of France?')
print('Result:', result)Memfilter Eksekusi berdasarkan Kesalahan dan Latensi
Gunakan klien LangSmith untuk menemukan eksekusi bermasalah secara terprogram. Filter berdasarkan status kesalahan, ambang latensi, atau label tertentu agar upaya debug Anda lebih terarah.
from langsmith import Client
from datetime import datetime, timedelta
client = Client(api_key='ls__your-key')
def find_slow_runs(project: str, latency_threshold_ms: int = 10000):
runs = list(client.list_runs(
project_name=project,
execution_order=1,
start_time=datetime.utcnow() - timedelta(hours=24)
))
slow_runs = []
for run in runs:
if run.end_time and run.start_time:
duration_ms = (run.end_time - run.start_time).total_seconds() * 1000
if duration_ms > latency_threshold_ms:
slow_runs.append({
'id': str(run.id),
'name': run.name,
'duration_ms': round(duration_ms),
'tags': run.tags
})
slow_runs.sort(key=lambda x: x['duration_ms'], reverse=True)
return slow_runs
print('Find slow runs function defined')
print('Usage: find_slow_runs("my-agent-project", latency_threshold_ms=5000)')Membandingkan Eksekusi
LangSmith memungkinkan Anda membandingkan dua eksekusi di antarmukanya untuk melihat perubahan yang terjadi. Secara terprogram, Anda dapat membandingkan keluaran eksekusi, penggunaan token, dan latensi untuk mendeteksi regresi setelah perubahan model atau instruksi.
from langsmith import Client
client = Client(api_key='ls__your-key')
def compare_runs(run_id_1: str, run_id_2: str) -> dict:
run1 = client.read_run(run_id_1)
run2 = client.read_run(run_id_2)
def get_tokens(run):
if run.total_tokens:
return run.total_tokens
return 0
def get_latency_ms(run):
if run.end_time and run.start_time:
return (run.end_time - run.start_time).total_seconds() * 1000
return 0
return {
'run1': {'id': run_id_1, 'tokens': get_tokens(run1), 'latency_ms': get_latency_ms(run1), 'status': run1.status},
'run2': {'id': run_id_2, 'tokens': get_tokens(run2), 'latency_ms': get_latency_ms(run2), 'status': run2.status},
'token_delta': get_tokens(run2) - get_tokens(run1),
'latency_delta_ms': get_latency_ms(run2) - get_latency_ms(run1)
}
print('Run comparison function defined')Menambahkan Skor dan Umpan Balik
Setelah mengevaluasi eksekusi agen, baik secara manual maupun otomatis, tambahkan skor atau umpan balik ke jejak tersebut. Hal ini membuat kumpulan data untuk penyetelan halus atau evaluasi perubahan instruksi.
from langsmith import Client
client = Client(api_key='ls__your-key')
def score_run(run_id: str, score: float, reasoning: str = ''):
# score: 0.0 (bad) to 1.0 (perfect)
client.create_feedback(
run_id=run_id,
key='quality',
score=score,
comment=reasoning
)
def auto_evaluate_run(run_id: str, expected_output: str, actual_output: str) -> float:
# Simple heuristic: check if key terms from expected output are present
expected_terms = set(expected_output.lower().split())
actual_terms = set(actual_output.lower().split())
overlap = len(expected_terms & actual_terms) / max(len(expected_terms), 1)
score = min(1.0, overlap * 1.5) # Normalize
score_run(run_id, score, f'Term overlap: {overlap:.2f}')
return score
print('Scoring functions defined')
print('Example: score_run("run-id-abc", 0.85, "Good answer but missing one detail")')Konteks Jejak Terstruktur
Lampirkan konteks yang bermakna ke jejak: ID sesi, ID pengguna, versi agen, dan penanda fitur. Dengan demikian, Anda dapat dengan mudah mengelompokkan jejak dan membandingkan performa di berbagai konfigurasi.
import os
from langsmith import traceable
from langchain_core.runnables import RunnableConfig
def build_trace_config(user_id: str, session_id: str, version: str) -> dict:
return {
'metadata': {
'user_id': user_id,
'session_id': session_id,
'agent_version': version,
'environment': os.environ.get('ENV', 'development')
},
'tags': [version, os.environ.get('ENV', 'development')],
'run_name': f'agent-{user_id[:8]}'
}
@traceable
def run_agent_with_context(question: str, user_id: str, session_id: str):
config = build_trace_config(user_id, session_id, 'v2.3')
# Pass config to any LangChain component
# llm.invoke([HumanMessage(content=question)], config=config)
print(f'Running agent for user {user_id}, session {session_id}')
return 'Answer here'
result = run_agent_with_context('Question', 'user-001', 'sess-xyz')
print(result)Menyiapkan Peringatan
Pantau kesehatan agen Anda dengan menyiapkan peringatan di LangSmith atau Langfuse. Berikan peringatan ketika tingkat kesalahan melampaui ambang batas, ketika latensi P99 melonjak, atau ketika langkah tertentu terus-menerus gagal.
from langsmith import Client
from datetime import datetime, timedelta
client = Client(api_key='ls__your-key')
def check_error_rate(project: str, window_minutes: int = 60, threshold: float = 0.05) -> dict:
runs = list(client.list_runs(
project_name=project,
execution_order=1,
start_time=datetime.utcnow() - timedelta(minutes=window_minutes)
))
if not runs:
return {'error_rate': 0.0, 'alert': False}
error_count = sum(1 for r in runs if r.status == 'error')
error_rate = error_count / len(runs)
if error_rate > threshold:
print(f'ALERT: Error rate {error_rate:.1%} exceeds threshold {threshold:.1%}')
# Send to Slack/PagerDuty here
return {
'total_runs': len(runs),
'error_count': error_count,
'error_rate': round(error_rate, 4),
'alert': error_rate > threshold
}
print('Error rate monitor defined')Uji Pemahaman: Pelacakan
Ujilah pemahaman Anda tentang pelacakan agen dengan LangSmith dan Langfuse.
Ringkasan Pelacakan
LangSmith dan Langfuse adalah alat yang saling melengkapi: LangSmith terintegrasi erat dengan LangChain dan memerlukan penyiapan minimal, sedangkan Langfuse dapat bekerja dengan kerangka kerja apa pun dan memberi Anda lebih banyak kendali. Keduanya mencatat masukan, keluaran, penggunaan token, latensi, dan kesalahan untuk setiap langkah agen. Gunakan pemfilteran, pemberian skor, dan peringatan untuk menjaga kualitas agen di lingkungan produksi.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Analisis Jejak dengan LangSmith dan Langfuse” gratis?
Ya — teks lengkap “Analisis Jejak dengan LangSmith dan Langfuse” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Agents, upgrade ke CoddyKit PRO. Kursus AI Agents mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Analisis Jejak dengan LangSmith dan Langfuse”?
Membaca jejak: mengidentifikasi alat yang lambat, keputusan yang keliru, dan pola kesalahan. Kamu berlatih AI Agents dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai AI Agents?
Tidak diperlukan pengalaman sebelumnya. AI Agents di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.
Berapa lama pelajaran “Analisis Jejak dengan LangSmith dan Langfuse” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Agents ini?
Ya. Setiap pelajaran AI Agents menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Analisis Jejak dengan LangSmith dan Langfuse
- Pembuatan Profil Token dan Biaya per Langkah
- Mengidentifikasi Langkah yang Lambat dan Mahal
- Analisis Akar Masalah Kegagalan Agen