LangSmith Dijelaskan: Men-debug dan Mengevaluasi Agen LLM

Pendahuluan

Membangun agen otonom dengan LLM dapat menjadi pengalaman yang membuat frustrasi dan tidak dapat diandalkan. Prompt dapat menghasilkan keluaran yang berbeda setiap kali dijalankan, alat-alat mungkin rusak tanpa tanda-tanda, dan model bisa mengalami halusinasi atau terjebak dalam loop tanpa indikator jelas. LangSmith adalah platform untuk menginstrumentasi, men-debug, mengevaluasi, dan memantau aplikasi LLM untuk mengatasi tantangan ini dan memberikan visibilitas menyeluruh terhadap perilaku agen Anda. Dalam tutorial ini, kita akan melalui loop keandalan agen yang khas: menginstrumentasi agen dengan pelacakan, men-debug jalannya agen secara otomatis dan manual, mengevaluasi kinerjanya, mengulangi prompt, dan akhirnya, memantau agen di lingkungan produksi. Pada akhirnya, Anda seharusnya memiliki pemahaman tentang apa itu LangSmith, bagaimana hal itu dapat membantu, dan bagaimana menggunakannya untuk membangun agen AI yang lebih andal.

Intisari Penting

• Observabilitas adalah dasar untuk keandalan agen: Dengan pelacakan LangSmith, setiap panggilan LLM, pemanggilan alat, dan langkah penalaran menengah dapat diamati, sehingga Anda dapat memahami mengapa agen melakukan tindakan tertentu tanpa harus menafsirkannya dari log.
• Jejak mengubah debugging menjadi analisis: Jejak yang terstruktur memungkinkan Anda memeriksa dan mendiagnosis dengan metode kegagalan prompt, kegagalan alat, masalah pengambilan, bug orkestrasi, dan memperbaiki titik kegagalan yang tepat.
• Evaluasi memungkinkan iterasi yang aman: Alur kerja evaluasi berbasis dataset LangSmith (tersedia secara offline maupun online) memungkinkan Anda mengukur kualitas aplikasi Anda, membandingkan versi prompt/model, dan mendeteksi regresi sebelum Anda merilis perubahan apa pun ke produksi.
• Rekayasa prompt menjadi lebih terstruktur: Prompt Playground dan versioning prompt mengubah prompt menjadi aset kelas utama yang dapat dilacak. Ini memungkinkan Anda berkolaborasi dalam pembuatan prompt, memastikan reproduksibilitas, dan mengontrol kapan serta bagaimana perubahan diterapkan ke produksi.
• Umpan balik manusia melengkapi proses: Antrian anotasi (satu kali dan berpasangan) memungkinkan Anda memanfaatkan penilaian manusia secara efektif dalam skala besar, meningkatkan penilai, dan memastikan kualitas di area di mana metrik otomatis kurang memadai.

Apa itu LangSmith (dan Kapan Layak Digunakan)

LangSmith adalah paket alat lengkap untuk membangun, men-debug, menguji, mengevaluasi, dan men-deploy aplikasi Anda yang didukung LLM. Dengan menggunakan Langsmith, Anda dapat:

• Lacak setiap permintaan (tangkap setiap langkah dari penalaran agen).
• Evaluasi keluaran Anda (pastikan agen Anda menghasilkan kualitas).
• Ulangi kembali prompt Anda dengan kontrol versi.
• Kelola penempatan agen Anda.

Berbeda dengan beberapa alat observabilitas, yang seringkali terikat erat dengan kerangka aplikasi LLM tertentu, LangSmith bersifat agnostik terhadap kerangka. Anda dapat menggunakannya dengan LangChain, LangGraph, atau kode kustom lainnya. Itu berarti Anda tidak perlu membangun agen Anda di LangChain untuk memanfaatkan fitur pelacakan dan evaluasi LangSmith.

Ini berguna dalam situasi apa pun di mana prompt memanggil alat atau API lain, atau jika Anda sedang menangani penalaran multi-langkah, atau dalam kasus apa pun di mana reproduktifitas dan debugging penting. Pada dasarnya, jika Anda sudah melewati batas pernyataan log sederhana dan ingin dapat memahami mengapa agen Anda melakukan apa yang dilakukannya, maka Anda sebaiknya melihat LangSmith.

Masalah Debugging Agen yang Diselesaikan oleh LangSmith

Mengembangkan agen otonom itu menantang karena agen sering gagal dengan cara yang halus dan tidak intuitif. Perubahan kecil pada prompt atau respons non-deterministik dari pemanggilan API alat dapat secara drastis mengubah rantai penalaran. Log dan metrik standar tidak cukup untuk memahami tindakan agen; Anda mungkin melihat agen mengembalikan hasil yang salah atau mengalami timeout, tetapi sumber kegagalannya tidak langsung terlihat. Apakah agen menggunakan alat yang salah untuk pekerjaan itu? Apakah promptnya kekurangan konteks? Apakah pemanggilan LLM memperkenalkan kesalahan halus yang muncul kemudian? Inilah jenis pertanyaan yang dapat dibantu dijawab oleh jejak LangSmith.

Men-debug agen tanpa jejak yang detail bisa berubah menjadi permainan tebak-tebakan. Agen bisa gagal tanpa memberi tanda dengan halusinasi atau terjebak dalam loop, dan Anda harus mencoba mereproduksi masalah secara buta. LangSmith mengatasi hal ini dengan merekam setiap langkah perjalanan agen (semua panggilan LLM, pemanggilan alat, prompt sementara, dll.) ke dalam garis waktu terstruktur yang disebut jejak. Memeriksa jejak memungkinkan Anda melihat dengan tepat apa yang salah.

Contoh: Misalkan Anda memiliki agen yang memanggil alat pencari untuk mencari informasi. Jika agen menghasilkan jawaban yang salah, masalahnya mungkin adalah: (1) alat pencari memberikan jawaban yang salah atau tidak ada hasil sama sekali (kegagalan alat), (2) LLM tidak menggunakan hasil pencarian dan mengarang jawaban (kegagalan prompt/penalaran), atau (3) logika agen tidak memanggil alat ketika seharusnya (kegagalan orkestrasi).

Jejak LangSmith akan mencakup setiap langkah: kueri dan hasil pemanggilan API pencarian, prompt agen yang dibuat dengan hasil tersebut, jawaban dari LLM, dan sebagainya. Dengan cara ini, Anda dapat segera melihat di mana rantai tersebut gagal mengikuti jalur yang diharapkan.

Mulai Cepat: Melacak Jalannya Agen (Contoh Python)

Selamat datang di contoh singkat tentang cara menggunakan LangSmith untuk menelusuri jalannya agen. Kami akan menggunakan Python (LangSmith juga memiliki SDK untuk pelacakan JavaScript/TypeScript dengan cara serupa, tetapi di sini ditunjukkan dengan Python). Dalam contoh ini, kita akan menambahkan instrumen pada panggilan LLM sederhana dan membangun jejak di UI LangSmith.

Prasyarat: Daftar untuk akun LangSmith gratis (jika belum) dan dapatkan kunci API Anda. Anda juga akan membutuhkan kunci API penyedia LLM Anda (misalnya, kunci API OpenAI). Instal paket-paket yang diperlukan:

pip install -U langsmith openai  # for this example

1. Aktifkan Pelacakan LangSmith. LangSmith bekerja dengan LangChain secara langsung – jika Anda sudah menggunakan LangChain, Anda dapat mengaktifkan pelacakan dengan satu variabel lingkungan. Pastikan ini diatur di lingkungan Anda (atau file .env):

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="<your-langsmith-api-key>"
export OPENAI_API_KEY="<your-openai-api-key>"

Ini memastikan bahwa pelacakan LangSmith aktif dan tervalidasi. (Jika Anda memiliki lebih dari satu workspace LangSmith, juga atur LANGSMITH_WORKSPACE_ID dengan tepat.) Anda juga dapat mengatur variabel ini dari Python menggunakan os.environ sebelum menginisialisasi LLM apa pun.

Penting: Flag LANGSMITH_TRACING=true harus diatur sebelum kode Anda menjalankan pemanggilan LLM, sehingga SDK dapat mencegatnya.

2. Bungkus atau Gunakan Klien LLM. Jika Anda menggunakan kelas LLM LangChain, Anda tidak perlu kode khusus untuk mencatat jejak – cukup pastikan variabel lingkungan sudah diatur. Misalnya, menggunakan pembungkus OpenAI dari LangChain:

import os
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = "<your-langsmith-api-key>"
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(model_name="gpt-3.5-turbo")  # This is LangChain's LLM wrapper
response = llm.predict("Hello, world!")
print(response)

Saat ini dijalankan, LangChain akan mendeteksi bahwa pelacakan diaktifkan dan mencatat panggilan ke LangSmith di latar belakang. Setelah menjalankan kode ini, Anda dapat mengunjungi antarmuka web LangSmith dan melihat jejaknya (di bawah daftar jejak proyek default).

Jika Anda tidak menggunakan LangChain, Anda dapat mengatur pemanggilan LLM Anda secara manual dengan SDK LangSmith. Misalnya, jika Anda ingin menelusuri pemanggilan API OpenAI secara langsung, LangSmith menawarkan bantuan wrap_openai:

from langsmith import wrappers
import openai
openai.api_key = os.environ["OPENAI_API_KEY"]
openai_client = wrappers.wrap_openai(openai.OpenAI())  # wrap the OpenAI client for tracing:contentReference[oaicite:14]{index=14}
# Now any call through openai_client will be traced:
result = openai_client.ChatCompletion.create(
   model="gpt-3.5-turbo",
   messages=[ {"role": "user", "content": "Hello, world?"} ]
)
print(result["choices"][0]["message"]["content"])

Di sini kami menggunakan langsmith.wrappers.wrap_openai untuk mendapatkan klien yang terlacak. LangSmith juga memiliki pembungkus serupa untuk penyedia lain (Anthropic, dll.). Setelah menjalankan kode ini, Anda juga akan melihat jejak lengkap di LangSmith, yang menunjukkan permintaan dan respons model.

3. Lihat Jejak. Beralih ke antarmuka LangSmith (aplikasi web). Pergi ke Observability/Traces. Anda seharusnya melihat entri baru untuk proses yang baru dijalankan di sana. Klik pada entri tersebut, dan Anda akan melihat tampilan terstruktur dari proses tersebut. Karena contoh kita sangat sederhana, mungkin hanya ada satu node panggilan LLM (dengan prompt dan output). Untuk rantai/agen yang lebih kompleks, itu akan menjadi pohon dari semua sub-langkah (misalnya, proses berpikir Agen dan setiap panggilan alat). Anda bisa memeriksa waktu, masukan/keluaran, bahkan berbagi jejak, menambahkan anotasi, dll. Visibilitas langsung ini membantu Anda memastikan semuanya berjalan dengan benar. Jika tidak (misalnya, ada kesalahan dalam rantai), Anda akan melihat persis di mana dan mengapa itu terjadi.

Tip: Jika dijalankan di lingkungan produksi, Anda mungkin tidak ingin menelusuri setiap proses (untuk menghemat biaya). LangSmith mendukung pengambilan sampel jejak atau mengaktifkan/nonaktifkan penelusuran melalui kode. Misalnya, Anda bisa mengaktifkan penelusuran untuk persentase tertentu dari permintaan atau untuk sesi tertentu (atur variabel lingkungan secara dinamis atau dengan SDK konfigurasi LangSmith). Untuk pengembangan dan debugging, mengaktifkannya secara global (seperti di atas) adalah cara termudah.

Jejak Membaca

Setelah Anda memiliki jejak, langkah berikutnya adalah mendiagnosis masalah. Jejak LangSmith sedikit mirip dengan catatan percobaan – ini adalah cara untuk mengkategorikan kegagalan dan mengidentifikasi pola. Berikut adalah beberapa mode kegagalan yang umum dan pola yang mereka buat dalam jejak:

Pikirkan jejak sebagai catatan penelitian. Klasifikasikan setiap masalah (prompt vs alat vs lainnya), ukur dampaknya (apakah terjadi kesalahan, atau hanya menurunkan kualitas jawaban?), dan Anda akan tahu persis apa yang perlu diperbaiki. Input, prompt, dan urutan alat bersifat eksplisit dan dapat diaudit dengan LangSmith; mutasi memori/status bersifat eksplisit; latensi, biaya, dan jalur kesalahan dapat diukur.

Alur Kerja Evaluasi: Dataset, Evaluator, dan Eksperimen

Pelacakan memberitahu Anda apa yang terjadi selama satu kali eksekusi. Evaluasi memberitahu Anda seberapa baik hasil tersebut, terutama ketika Anda harus mengukur kualitas di banyak eksekusi atau membandingkan versi berbeda dari agen Anda. LangSmith memiliki alur kerja evaluasi lengkap untuk mendukung pengujian offline maupun pemantauan online terhadap kualitas aplikasi LLM Anda.

Evaluasi Offline vs Online: LangSmith mendukung kedua mode tersebut. Evaluasi offline adalah yang Anda lakukan sebelum mengirim perubahan - Anda menyiapkan dataset dari contoh input (dan opsional output yang diharapkan), lalu menjalankan agen Anda pada semuanya untuk melihat kinerjanya. Ini sangat berguna untuk menangkap regresi dan membandingkan versi prompt/model dalam pengaturan yang terkontrol. Evaluasi online, sebaliknya, dijalankan di produksi - secara terus-menerus mengevaluasi interaksi pengguna nyata saat terjadi, untuk memantau kualitas pada data langsung. Keduanya berguna: evaluasi offline seperti uji unit/integrasi untuk agen Anda, dan evaluasi online seperti pemantauan langsung atau pengujian canary.

Alur evaluasi tipikal di LangSmith terlihat seperti ini:

1. Buat Dataset: Sekumpulan kasus uji untuk agen Anda. Ini bisa dikumpulkan dari kegagalan sebelumnya (jejak agen Anda memberikan respons yang salah), contoh sintetis yang menurut Anda menantang, atau pertanyaan pengguna yang ingin Anda pastikan tercakup. Di LangSmith, dataset hanyalah sekumpulan pasangan input-output (atau hanya input, jika Anda tidak memiliki output "kebenaran dasar"). Anda dapat membuat dan mengelola dataset menggunakan UI atau SDK. Sebagai contoh, dalam Python:

from langsmith import Client
client = Client()
dataset = client.create_dataset("MathQA set", description="Simple math Q&A tests")
client.create_examples(dataset.id, examples=[
   {"inputs": {"question": "What is 2+2?"}, "outputs": {"answer": "4"}},
   {"inputs": {"question": "What is the capital of France?"}, "outputs": {"answer": "Paris"}}
])

Ini akan secara programatis membuat dataset dengan dua contoh Tanya & Jawab. (Anda juga bisa mengunggah dataset dari CSV/JSON atau membuatnya di antarmuka pengguna.)

2. Definisikan Evaluator: Evaluator adalah fungsi atau model yang memberi skor pada keluaran agen Anda untuk setiap contoh. LangSmith dilengkapi dengan beberapa evaluator bawaan dan mendukung evaluator kustom. Jenis evaluator yang umum meliputi:

• Kebenaran (Kejujuran): Apakah keluaran berisi jawaban yang sama dengan jawaban referensi yang diketahui benar? (Untuk ini, Anda perlu memiliki keluaran referensi dalam dataset Anda.)
• Penilaian Rubrik: fungsi Python kustom atau heuristik untuk memeriksa sesuatu (misalnya, “apakah keluaran menyertakan kutipan?”).
• LLM-sebagai-Hakim: Gunakan LLM lain untuk menilai kualitas keluaran. Misalnya, sebuah fungsi OpenAI dapat membandingkan keluaran dengan referensi dan memberikan skor.
• Perbandingan Berpasangan: Gunakan ini ketika Anda memiliki dua hasil (misalnya, dari model A vs. model B) dan ingin menentukan mana yang lebih baik.

Anda dapat menambahkan satu atau banyak evaluator ke sebuah eksperimen. LangSmith menggunakan library OpenEvals (evaluator sumber terbuka) untuk ini. Misalnya, untuk menggunakan evaluator LLM-sebagai-hakim untuk menilai kebenaran, Anda akan mengimpor prompt seperti CORRECTNESS_PROMPT dan melakukan:

from openevals.llm import create_llm_as_judge
from openevals.prompts import CORRECTNESS_PROMPT
judge = create_llm_as_judge(prompt=CORRECTNESS_PROMPT)

Seperti yang bisa Anda lihat, hakim ini kemudian dapat digunakan untuk menilai setiap keluaran (secara efektif menanyakan kepada LLM dengan ‘Apakah jawaban ini benar berdasarkan referensi?’, lalu mengembalikan sebuah skor)*

3. Jalankan Eksperimen: Sekarang bagian yang menyenangkan – jalankan agen Anda pada dataset dan kumpulkan hasilnya. Di antarmuka LangSmith, Anda akan membuat Eksperimen baru, memilih dataset dan fungsi target (agen/rangkaian Anda) untuk dijalankan, melampirkan evaluator, dll. Jika Anda menggunakan kode, Anda bisa menggunakan Client.run_on_dataset atau sesuatu yang serupa.

client = Client()
# Assuming `target_fn` is your function that takes an input dict and returns an output dict
experiment = client.run_on_dataset(
   dataset_name="MathQA set",
   func=target_fn,
   evaluators=[judge]  # the evaluator we defined
)

Ini akan menjalankan target_fn Anda untuk setiap contoh dalam dataset, mencatat hasilnya, dan kemudian evaluator akan memberi skor untuk setiap hasil. LangSmith akan menyimpan semua data yang dicatat ini dalam objek Eksperimen yang bisa Anda periksa.

Di antarmuka pengguna, menjalankan eksperimen akan menampilkan tabel hasil yang diperbarui secara langsung – Anda akan melihat setiap contoh, keluaran model, dan skor dari evaluator. Ini berguna untuk mengidentifikasi pola (misalnya, "agen gagal pada semua pertanyaan matematika yang melibatkan pembagian").

4. Analisis Hasil: Setelah eksperimen selesai, Anda dapat membandingkan dan menganalisis hasil percobaan Anda di LangSmith. Urutkan dan saring hasil berdasarkan skor, saring contoh (misalnya, “tunjukkan contoh di mana skor kebenarannya rendah”), bandingkan dua eksperimen jika Anda menjalankan lebih dari satu (misalnya, bandingkan Agent v1 vs Agent v2 pada dataset yang sama), dan lain-lain. Ini berguna baik untuk membandingkan versi prompt/model yang berbeda maupun untuk membuat “tes regresi” (Anda bisa menyimpan secara harfiah “set emas” dari contoh, lalu memastikan versi mendatang tidak menurunkan skor pada contoh tersebut).

5. Iterasi Perbaikan: Jika evaluasinya tidak cukup baik, Anda akan menyempurnakan agen dengan beberapa cara (meningkatkan prompt, mengubah contoh, memperbaiki cara agen menggunakan alat, dll.) dan melakukan eksperimen baru.

Salah satu alur kerja yang sangat berguna adalah Prompt Playground (antarmuka "tanpa kode" di LangSmith) untuk menjalankan evaluasi cepat pada berbagai varian prompt. Playground memungkinkan Anda memuat dataset, mencoba berbagai template prompt atau parameter model, dan langsung melihat skor evaluasinya.

Satu catatan terakhir – Evaluasi tidak selalu dilakukan dengan otomatisasi. Terkadang, metrik otomatis/penilai LLM tidak menangkap beberapa aspek penting. Di sinilah ulasan/evaluasi manusia diperlukan – dan LangSmith juga mendukung ini melalui antrian anotasi, yang akan kita lihat pada bagian berikutnya.

Manusia dalam Loop: Antrian Anotasi untuk Kualitas dalam Skala Besar

Evaluator otomatis memang bagus, tetapi pada suatu titik, Anda akan memerlukan evaluasi manusia untuk mendapatkan skor yang paling akurat. Antrian anotasi LangSmith adalah cara yang sederhana dan dapat ditingkatkan untuk mendapatkan tinjauan manusia terhadap output agen Anda. Anda dapat memasukkan output model ke dalam antrian untuk ditinjau, dan anotator manusia (Anda sendiri, rekan kerja, atau pemberi label profesional) dapat menilainya berdasarkan rubrik yang telah ditentukan.

LangSmith mendukung dua gaya antrean anotasi:

• Antrian Anotasi Satu Kali Jalankan: Gaya ini menampilkan satu output (satu kali jalankan) pada satu waktu kepada peninjau, bersama dengan rubrik atau pertanyaan untuk dijawab mengenai output tersebut. Ini bisa sesederhana "Apakah jawaban ini benar secara faktual? (Ya/Tidak)" atau "Nilailah kejelasan jawaban dari 1-5." Peninjau akan melihat konteks penuh (prompt, output, dan mungkin jawaban referensi jika Anda memilikinya) dan mengirimkan umpan balik untuk jalankan tersebut.
• Antrian Anotasi Berpasangan (PAQ): Ini menampilkan dua output berdampingan dan meminta peninjau untuk memilih mana yang lebih baik (atau jika keduanya sama) berdasarkan beberapa kriteria. Ini berguna untuk pengujian A/B – misalnya, Anda memiliki Agen Versi A dan Versi B yang menjawab pertanyaan yang sama, dan Anda ingin seorang manusia memutuskan mana yang melakukan pekerjaan lebih baik. Perbandingan berpasangan juga sangat berguna jika Anda ingin membandingkan model atau prompt baru dengan yang lama, yang merupakan kasus penggunaan umum untuk fine-tuning atau RLHF.

Kapan menggunakan yang mana? Antrian satu kali jalan bagus untuk mendapatkan penilaian absolut atau label kategoris pada hasil (bagus jika Anda sedang membuat dataset skor manusia untuk melatih evaluator, atau sekadar memantau kualitas).

Pairwise berguna ketika kualitas relatif lebih penting, yaitu, ketika Anda ingin memastikan versi baru adalah peningkatan, dan Anda ingin tahu seberapa banyak orang lebih menyukainya. Dalam praktiknya, banyak tim menggunakan pairwise saat melakukan pemodelan preferensi atau pembelajaran penguatan dari umpan balik manusia (RLHF). Ini karena lebih mudah bagi manusia untuk mengatakan "mana dari dua ini yang lebih baik" daripada memberikan skor absolut.

LangSmith vs Alternatif: Bagaimana Perbandingannya

Ruang observabilitas/umpan balik LLM sedang berkembang, dan beberapa alat telah muncul yang bertumpang tindih dengan fitur LangSmith. Berikut adalah perbandingan singkat antara LangSmith dan beberapa alternatif populer, beserta beberapa tips untuk memilih alat yang tepat sesuai kebutuhan Anda:

FAQ

Q1: Apakah saya perlu LangChain untuk menggunakan LangSmith?

Tidak. LangSmith tidak tergantung pada framework tertentu. Anda bisa menggunakannya dengan LangChain, LangGraph, atau tanpa framework sama sekali. Jika Anda sudah menggunakan LangChain, bagus – LangSmith bisa terhubung dengan pengaturan minimal (cukup atur variabel lingkungan, dan otomatis akan merekam chain/agent untuk Anda). Jika Anda tidak menggunakan framework, Anda bisa menelusuri panggilan LLM atau logika agent secara manual dengan SDK LangSmith.

Q2: Bisakah saya mengevaluasi prompt tanpa menulis kode?

Ya. LangSmith menyediakan Prompt Playground dan antarmuka pengguna untuk evaluasi yang memungkinkan Anda melakukan banyak hal tanpa coding. Misalnya, Anda bisa membuat dataset dan menjalankan eksperimen sepenuhnya dari antarmuka web – cukup isi contoh, pilih evaluator dari menu dropdown, dan tekan Mulai.

Q3: Apa perbedaan antara anotasi sekali jalan dan anotasi berpasangan di LangSmith?

Dalam anotasi satu kali jalan, seorang peninjau manusia diberikan satu hasil (satu putaran) pada satu waktu dan memberikan umpan balik berdasarkan rubrik (misalnya, menilai kebenaran atau kualitas lainnya). Dalam anotasi berpasangan, peninjau ditunjukkan dua hasil secara berdampingan (biasanya dari dua versi model yang berbeda untuk input yang sama) dan diminta memilih mana yang lebih baik atau jika keduanya sama. Anotasi satu kali jalan digunakan untuk menilai sebuah hasil secara terisolasi. Anotasi berpasangan digunakan untuk membandingkan hasil-hasil.

Q4: Apa yang perlu saya atur agar panggilan LLM saya dapat dilacak oleh LangSmith?

Pengaturan penting adalah mengaktifkan pelacakan melalui variabel lingkungan atau konfigurasi. Ini bisa dilakukan dengan menggunakan variabel lingkungan atau melalui konfigurasi. Cara paling sederhana adalah dengan mengatur variabel lingkungan LANGSMITH_TRACING=true sebelum menjalankan aplikasi Anda. Anda juga perlu mengatur kunci API Anda (LANGSMITH_API_KEY) agar data terkait dengan akun Anda, dan tentu saja, kunci API model apa pun (seperti OPENAI_API_KEY). Dengan LANGSMITH_TRACING=true, setiap integrasi yang didukung (LangChain, dll.) akan mulai mencatat log. Jika variabel lingkungan tidak memungkinkan, LangSmith juga mendukung pengaktifan secara programatik – misalnya, dalam Python:

from langsmith import Client
client = Client()
client.configure_tracing(True)

Ini adalah contoh hipotetis; API yang sebenarnya mungkin berbeda, tetapi secara konsep, Anda bisa mengaktifkannya di kode. Jalankan chain/agen Anda — Anda seharusnya melihat jejak di UI LangSmith. Jika tidak, periksa kembali bahwa variabel lingkungan Anda sudah didefinisikan di konteks yang sama dengan kode yang sedang dijalankan (dan workspace yang benar jika berlaku).

Q5: Apakah LangSmith hanya untuk pelacakan, atau juga menangani penerapan?

LangSmith dibangun dengan mempertimbangkan observabilitas dan evaluasi, tetapi juga memiliki modul Deployment. Anda dapat menyebarkan agen sebagai endpoint yang dikelola melalui LangSmith (mereka menyebutnya sebagai Server Agen), dan mendapatkan kemampuan skala, waktu operasional, dan pemantauan secara langsung.

Kesimpulan

LangSmith membantu Anda mengembangkan agen dari proses coba-coba menjadi alur kerja teknik. Dengan pelacakan, evaluasi, versi prompt, dan ulasan manusia, Anda dapat mendiagnosis kegagalan, mengukur perbaikan, dan mencegah regresi mencapai pengguna. Kebiasaan utama dalam pengembangan agen adalah loop keandalan agen: lacak setiap jalannya, ubah kegagalan nyata menjadi dataset, jalankan eksperimen yang dapat diulang menggunakan evaluator (diperkuat oleh manusia jika diperlukan), lalu promosikan hanya perubahan prompt/model terbaik melalui rilis versi. Pelacakan dan pemantauan operasi memungkinkan Anda menerima peringatan dini terkait terjadinya drift, kegagalan alat, fluktuasi latensi, dan dampak keuangan yang tidak terduga. LangSmith menawarkan solusi terstruktur bagi pengembang agen yang menggunakan alat atau agen multi-langkah yang memprioritaskan reproduktibilitas dan iterasi terkontrol selama pengembangan dari prototipe hingga produksi.

Referensi

• Dokumen LangSmith
• Apa itu LangSmith? Pelacakan dan debug untuk LLM
• Alternatif LangSmith? Langfuse vs. LangSmith
• Pelacakan LangSmith: Debugging rantai LLM
• Panduan cepat penelusuran
• Evaluasi LangSmith
• Panduan cepat evaluasi
• Gunakan antrean anotasi
• Konsep observabilitas
• Panduan Lengkap Platform Observabilitas LLM di 2025
• OpenTelemetry untuk GenAI dan proyek OpenLLMetry

Terima kasih telah belajar bersama Komunitas Linux-Console.net.