{"id":3135,"date":"2026-11-18T08:13:43","date_gmt":"2026-11-18T01:13:43","guid":{"rendered":"https:\/\/komunitech.com\/blog\/?p=3135"},"modified":"2026-11-18T08:13:43","modified_gmt":"2026-11-18T01:13:43","slug":"panduan-ai-agent-observability-langfuse","status":"publish","type":"post","link":"https:\/\/komunitech.com\/blog\/ai-agent\/panduan-ai-agent-observability-langfuse\/","title":{"rendered":"Panduan AI Agent Observability: Cara Melacak Log, Latensi, dan Debugging AI Agent di Produksi Pakai Langfuse"},"content":{"rendered":"<blockquote>\n<p><strong>Jawaban singkatnya dulu, ya. <\/strong><\/p>\n<p>Langfuse adalah platform open-source buat ngelihat apa yang sebenarnya dilakukan AI agent kamu di produksi: setiap prompt, tool call, retrieval, jawaban model, token, biaya, dan latensinya direkam sebagai trace yang bisa kamu buka dan telusuri langkah demi langkah. Pasang SDK-nya, isi tiga environment variable, dan tiap request yang masuk langsung kelihatan pohon eksekusinya. Jadi waktu ada jawaban yang ngaco, kamu tahu persis langkah mana yang salah, bukan cuma nebak-nebak dari log biasa.<\/p>\n<\/blockquote>\n<h2>Agent kamu jawabannya ngaco, tapi log-nya bilang semua normal<\/h2>\n<p>Bayangin skenarionya. Ada user komplain: agent customer service kamu jawabnya ngawur, nyebut kebijakan refund yang nggak pernah ada. Kamu buka log aplikasi. Status 200 semua. Nggak ada exception. Latensi normal. Dari sudut pandang server, semuanya sehat.<\/p>\n<p>Di situlah masalahnya. Kegagalan AI agent itu seringnya <em>silent<\/em>. Bukan crash, bukan error \u2014 tapi jawaban yang salah dengan percaya diri. Retrieval-nya ngambil dokumen yang keliru. Tool-nya dipanggil dengan argumen yang meleset. Prompt-nya berubah diam-diam waktu ada deploy. Atau modelnya menjawab dari hafalan, bukan dari konteks yang kamu kasih.<\/p>\n<p>Monitoring tradisional \u2014 uptime, error rate, CPU \u2014 nggak bisa nangkap kegagalan semacam itu. Yang kamu butuhin adalah rekaman lengkap tiap langkah agent: input apa yang masuk, konteks apa yang dipakai, tool apa yang dipanggil, dan output apa yang keluar. Itu yang disebut observability buat LLM, dan itu persis yang dikerjain Langfuse.<\/p>\n<h2>Langfuse itu apa, sih?<\/h2>\n<p>Langfuse adalah platform AI engineering open-source yang isinya tiga hal yang saling nyambung: <strong>observability<\/strong> (tracing), <strong>prompt management<\/strong>, dan <strong>evaluasi<\/strong>. Kamu bisa pakai versi cloud-nya yang sudah dikelola (Langfuse Cloud), atau self-host di infrastrukturmu sendiri dengan kode yang sama \u2014 yang beda cuma kredensial dan base URL-nya.<\/p>\n<p>Sejak Januari 2026, Langfuse jadi bagian dari ClickHouse, database open-source yang memang sudah dipakai Langfuse buat nyimpen trace sejak awal. Core-nya berlisensi MIT dan bisa di-self-host gratis; sebagian fitur enterprise tinggal di direktori terpisah dengan lisensi komersial.<\/p>\n<p>Satu hal yang sering bikin salah paham: namanya Langfuse, tapi dia <strong>nggak terikat sama LangChain<\/strong>. Dia jalan di atas OpenTelemetry, standar terbuka buat tracing, jadi bisa dipakai bareng framework apa pun, provider model apa pun, atau panggilan SDK polos sekalipun.<\/p>\n<h2>Model datanya: trace, observation, dan session<\/h2>\n<p>Semua yang direkam Langfuse berangkat dari satu ide: satu request utuh direkam sebagai <strong>trace<\/strong>, dan di dalamnya ada langkah-langkah yang disebut <strong>observation<\/strong>. Observation bisa bersarang \u2014 sebuah span bisa berisi generation, yang di dalamnya ada span lain lagi \u2014 persis ngikutin struktur kode kamu.<\/p>\n<table>\n<tbody>\n<tr>\n<th><strong>Konsep<\/strong><\/th>\n<th><strong>Artinya<\/strong><\/th>\n<th><strong>Contoh<\/strong><\/th>\n<\/tr>\n<tr>\n<td>Trace<\/td>\n<td>Satu request utuh, dari pertanyaan user sampai jawaban akhir<\/td>\n<td>Satu pesan chat yang dijawab agent<\/td>\n<\/tr>\n<tr>\n<td>Span<\/td>\n<td>Satu unit kerja non-LLM di dalam trace<\/td>\n<td>Retrieval ke vector database, parsing, validasi<\/td>\n<\/tr>\n<tr>\n<td>Generation<\/td>\n<td>Satu panggilan ke model, lengkap dengan model, parameter, token, dan biaya<\/td>\n<td>Panggilan chat completion ke GPT atau Claude<\/td>\n<\/tr>\n<tr>\n<td>Event<\/td>\n<td>Penanda satu titik waktu di dalam trace<\/td>\n<td>User menekan tombol, guardrail menolak output<\/td>\n<\/tr>\n<tr>\n<td>Session<\/td>\n<td>Kelompok trace yang termasuk satu interaksi multi-turn<\/td>\n<td>Satu thread chat berisi 12 pesan<\/td>\n<\/tr>\n<tr>\n<td>Score<\/td>\n<td>Penilaian kualitas yang ditempel ke trace, observation, atau session<\/td>\n<td>Thumbs-down user, skor relevansi dari LLM-as-a-judge<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Ada juga tipe observation yang lebih spesifik, misalnya <code>agent<\/code>, <code>tool<\/code>, <code>retriever<\/code>, <code>evaluator<\/code>, dan <code>guardrail<\/code>, supaya langkah-langkah di trace gampang difilter dan dibaca di dashboard.<\/p>\n<p>Dua atribut yang paling sering kepakai di produksi: <code>user_id<\/code> dan <code>session_id<\/code>. Dengan <code>user_id<\/code>, kamu bisa ngelihat biaya dan kualitas per akun. Dengan <code>session_id<\/code>, semua trace dalam satu percakapan bisa dibuka sebagai satu kesatuan, lengkap dengan session replay \u2014 nonton ulang seluruh interaksinya dari awal sampai akhir.<\/p>\n<h2>Setup-nya: lima menit sampai trace pertama<\/h2>\n<p>Jalur tercepat adalah Langfuse Cloud: bikin akun, bikin project, lalu salin API key dari project settings. Kalau kamu mau self-host, jalur resminya pakai Docker Compose dari repositori Langfuse (detailnya ada di bagian bawah artikel ini).<\/p>\n<p>Terus instal SDK Python-nya:<\/p>\n<pre><code>pip install langfuse openai<\/code><\/pre>\n<p>Lalu isi tiga environment variable. Ini yang dipakai SDK versi sekarang:<\/p>\n<pre><code>LANGFUSE_PUBLIC_KEY=\"pk-lf-...\"\r\nLANGFUSE_SECRET_KEY=\"sk-lf-...\"\r\nLANGFUSE_BASE_URL=\"https:\/\/cloud.langfuse.com\"  # region EU, default<\/code><\/pre>\n<p>Catatan kecil yang sering bikin bingung: tutorial-tutorial lama masih menulis <code>LANGFUSE_HOST<\/code>. Itu nama lama \u2014 dokumentasi sekarang pakai <code>LANGFUSE_BASE_URL<\/code>. Kalau kamu self-host atau pakai region lain (AS, Jepang, atau HIPAA), arahkan variable ini ke URL instance kamu. Secret key-nya perlakukan kayak kredensial lain: jangan pernah di-commit ke repo.<\/p>\n<p>Contoh paling ringkas, pakai decorator <code>@observe<\/code> dan drop-in OpenAI dari Langfuse. Drop-in ini cuma ganti import \u2014 panggilan OpenAI kamu tetap sama, tapi tiap panggilan otomatis tercatat sebagai generation lengkap dengan model, token, biaya, dan latensi:<\/p>\n<pre><code>from langfuse import observe, get_client, propagate_attributes\r\nfrom langfuse.openai import openai  # drop-in, ganti import openai biasa\r\n\r\nlangfuse = get_client()\r\n\r\n@observe()\r\ndef jawab_pertanyaan(pertanyaan: str, user_id: str) -&gt; str:\r\n    # session_id dan user_id nempel ke semua observation di dalamnya\r\n    with propagate_attributes(session_id=f\"chat-{user_id}\", user_id=user_id):\r\n        completion = openai.chat.completions.create(\r\n            model=\"gpt-4o-mini\",\r\n            messages=[\r\n                {\"role\": \"system\", \"content\": \"Kamu asisten customer service yang ringkas.\"},\r\n                {\"role\": \"user\", \"content\": pertanyaan},\r\n            ],\r\n        )\r\n        return completion.choices[0].message.content\r\n\r\nif __name__ == \"__main__\":\r\n    print(jawab_pertanyaan(\"Di mana status pesanan saya?\", user_id=\"user-123\"))\r\n    langfuse.flush()  # wajib di script pendek, supaya trace kekirim sebelum proses selesai<\/code><\/pre>\n<p>Jalankan script itu, buka dashboard Langfuse, dan kamu bakal nemu satu trace berisi generation dari panggilan OpenAI tadi. Fungsi yang didekorasi paling luar jadi trace-nya; fungsi berdekorasi lain yang dipanggil di dalamnya otomatis jadi span atau generation di bawahnya, lengkap dengan input, output, timing, dan error kalau ada.<\/p>\n<p>Kalau aplikasimu bukan Python, ada SDK JavaScript\/TypeScript yang modular \u2014 paket tracing, OTel, dan integrasi OpenAI\/LangChain-nya dipasang terpisah \u2014 dan buat bahasa lain, kamu bisa kirim span OpenTelemetry langsung ke endpoint OTel Langfuse, lalu pakai public API buat fitur prompt dan evaluasi.<\/p>\n<p>Satu peringatan versi yang penting: SDK Python ditulis ulang berbasis OpenTelemetry dan rilis besarnya keluar Maret 2026. Pola lama kayak <code>langfuse.trace()<\/code>, <code>span()<\/code>, dan <code>generation()<\/code> sudah deprecated. Kalau kamu nemu tutorial yang masih pakai pola itu, jangan ditiru buat kode baru \u2014 pakai <code>@observe<\/code>, <code>get_client()<\/code>, dan context manager seperti contoh di atas.<\/p>\n<h2>Latensi dan biaya: dua angka yang bikin tagihan ketahuan<\/h2>\n<p>Setiap generation di Langfuse nyimpen dua hal, dipecah per jenis pemakaian (input, output, token cache, dan sejenisnya): <strong>usage details<\/strong> (berapa unit yang kepakai) dan <strong>cost details<\/strong> (berapa dolarnya). Kebanyakan integrasi nangkap keduanya otomatis, jadi dalam banyak kasus kamu nggak perlu setting apa-apa.<\/p>\n<p>Cara Langfuse ngitung biaya ada dua jalur. Kalau kamu kirim cost-nya langsung (misalnya dari invoice gateway), angka kiriman itu yang dipakai. Kalau tidak, Langfuse menghitung sendiri dari usage dan nama model, pakai definisi model bawaan yang sudah berisi harga model-model populer dari OpenAI, Anthropic, dan Google. Buat model custom atau self-hosted, kamu bisa daftarkan definisi model sendiri di Project Settings &gt; Models. Yang perlu diingat: kalau usage-nya nggak kekirim, nggak ada biaya yang dihitung \u2014 Langfuse sudah tidak lagi menebak-nebak jumlah token dari teks input dan output.<\/p>\n<p>Di dashboard, angka-angka ini bisa diagregasi per model, per user, per session, per fitur, atau per periode. Itu yang bikin kamu bisa jawab pertanyaan bisnis yang konkret: fitur mana yang paling mahal, user mana yang paling boros, dan apakah ganti prompt kemarin bikin biaya naik. <a href=\"https:\/\/komunitech.com\/blog\/ai-agent\/llm-terbaik-untuk-ai-agent-2026-gpt-vs-claude-vs-gemini\/\">Pemilihan model<\/a> sendiri ngaruh besar ke dua angka ini \u2014 model yang lebih murah tapi sering salah bisa lebih mahal di ujung karena request-nya diulang.<\/p>\n<p>Buat latensi, tiap observation nyimpen timestamp mulai dan selesainya, jadi kamu bisa lihat langkah mana yang makan waktu paling lama di dalam satu trace. Kalau mau proaktif, pasang alert: Langfuse bisa memantau metrik kayak p95 latensi, rata-rata biaya, atau skor evaluasi, lalu ngasih tahu waktu angkanya melewati ambang yang kamu tentukan.<\/p>\n<h2>Workflow debugging-nya: dari komplain user sampai akar masalah<\/h2>\n<p>Ini alur yang paling sering kepakai waktu ada yang salah di produksi. Anggap ada user yang lapor jawaban agent-nya ngawur:<\/p>\n<p><strong>1. Temukan trace-nya.<\/strong> Cari berdasarkan <code>user_id<\/code>, <code>session_id<\/code>, atau rentang waktu di daftar trace. Kalau percakapannya multi-turn, buka session view-nya dan replay seluruh interaksinya.<\/p>\n<p><strong>2. Baca pohon trace-nya.<\/strong> Lihat langkah demi langkah: retrieval-nya mengembalikan dokumen apa, tool apa yang dipanggil dengan argumen apa, dan generation mana yang menghasilkan jawaban akhir. Langkah yang lambat atau gagal langsung kelihatan.<\/p>\n<p><strong>3. Periksa input dan output tiap generation.<\/strong> Di sinilah akar masalah biasanya ketemu: konteks retrieval yang salah, prompt yang versinya bukan yang kamu kira, atau tool yang mengembalikan data kosong sehingga model terpaksa ngarang.<\/p>\n<p><strong>4. Bandingkan dengan trace yang bagus.<\/strong> Cari trace serupa yang jawabannya benar, lalu sandingkan: bedanya di langkah yang mana? Cara ini jauh lebih cepat daripada membaca ulang kode dari nol.<\/p>\n<p><strong>5. Kasih skor, supaya masalahnya terukur.<\/strong> Skor bisa datang dari tiga arah: manual dari tim kamu di UI, dari user langsung (tombol thumbs-up\/down yang dikirim sebagai score), atau otomatis lewat evaluator LLM-as-a-judge dan code evaluator yang jalan di traffic produksi. Skor bisa numerik, kategorikal, atau boolean, dan bisa ditempel ke trace, observation, bahkan session.<\/p>\n<p><strong>6. Jadikan trace yang gagal sebagai test case.<\/strong> Langfuse punya datasets dan experiments: kumpulkan contoh-contoh gagal dari produksi, lalu jalankan ulang aplikasimu terhadap dataset itu setiap kali prompt atau model berubah. Dengan begitu, perbaikan yang kamu buat nggak diam-diam merusak kasus yang sebelumnya sudah benar.<\/p>\n<p>Buat tim yang lebih besar, ada annotation queue \u2014 antrean review manusia yang terstruktur buat trace, observation, dan session \u2014 dan dashboard kustom buat memantau tren skor dan biaya dari waktu ke waktu. Intinya sama: debugging yang tadinya tebakan berubah jadi pekerjaan yang bisa dilacak.<\/p>\n<h2>Prompt management: berhenti hardcode prompt di kode<\/h2>\n<p>Salah satu sumber bug paling menyebalkan di aplikasi LLM adalah prompt yang tersebar di codebase. Ada yang di file konfigurasi, ada yang ditempel di fungsi, ada yang cuma hidup di satu branch yang lupa di-merge. Waktu kualitas jawaban turun, nggak ada yang tahu prompt versi berapa yang sebenarnya jalan di produksi.<\/p>\n<p>Langfuse nyimpen prompt sebagai objek berversi. Setiap kali disimpan, tercipta versi baru yang immutable \u2014 versi lama nggak pernah diubah di tempat. Di atas versi ada <strong>label<\/strong> yang berfungsi kayak pointer deployment: <code>production<\/code>, <code>staging<\/code>, <code>latest<\/code>, atau label bikinanmu sendiri. Kode mengambil prompt berdasarkan label, jadi deploy prompt baru tinggal memindahkan label, dan rollback tinggal memindahkannya balik \u2014 tanpa deploy ulang aplikasi.<\/p>\n<p>Di sisi aplikasi, polanya begini: ambil prompt dengan <code>get_prompt()<\/code>, compile dengan variabel request-nya, lalu tautkan prompt itu ke generation yang memakainya, supaya setiap trace mencatat persis versi prompt mana yang menghasilkan output itu. SDK meng-cache prompt di sisi client dengan TTL default 60 detik dan refresh di background, jadi fetch prompt nggak nambah latency ke request. Ada juga fallback buat menjaga aplikasi tetap jalan kalau API Langfuse nggak bisa dijangkau saat fetch pertama.<\/p>\n<p>Buat eksperimen, ada playground di UI yang bisa membandingkan beberapa varian prompt berdampingan, masing-masing dengan setting model, variabel, dan definisi tool sendiri. Prompt yang sama juga bisa dipakai di dataset experiment, jadi kamu bisa menguji versi baru terhadap kasus-kasus lama sebelum label <code>production<\/code> dipindahkan.<\/p>\n<h2>Integrasi: hampir semua stack ketemu di sini<\/h2>\n<table>\n<tbody>\n<tr>\n<th><strong>Stack kamu<\/strong><\/th>\n<th><strong>Cara integrasinya<\/strong><\/th>\n<\/tr>\n<tr>\n<td>OpenAI SDK (Python \/ JS)<\/td>\n<td>Drop-in replacement: ganti import, panggilan tercatat otomatis sebagai generation<\/td>\n<\/tr>\n<tr>\n<td>LangChain \/ LangGraph<\/td>\n<td><code>CallbackHandler<\/code> dari <code>langfuse.langchain<\/code>, dipasang lewat <code>config={\"callbacks\": [handler]}<\/code><\/td>\n<\/tr>\n<tr>\n<td>LlamaIndex, LiteLLM, dan kawan-kawan<\/td>\n<td>Integrasi native yang mengubah event framework jadi observation<\/td>\n<\/tr>\n<tr>\n<td>Framework atau bahasa lain<\/td>\n<td>Kirim span OpenTelemetry langsung ke endpoint OTel Langfuse; fitur lain lewat public API<\/td>\n<\/tr>\n<tr>\n<td>AI Gateway (beta)<\/td>\n<td>Route panggilan model lewat satu endpoint, tercatat otomatis<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Karena fondasinya OpenTelemetry, instrumentasi pihak ketiga yang sudah OTel-native otomatis muncul di dalam trace Langfuse \u2014 dan sebaliknya, kamu bisa mengekspor span yang sama ke sistem observability lain yang sudah kamu pakai. Kalau agent kamu dibangun di atas <a href=\"https:\/\/komunitech.com\/blog\/ai-agent\/framework-multi-agent-ai-terbaik-2026-langgraph-crewai-autogen-claude-openclaw\/\">framework multi-agent kayak LangGraph atau CrewAI<\/a>, pola callback di atas biasanya cukup: satu request jadi satu trace, semua node, tool call, dan panggilan LLM-nya kelihatan bersarang di dalamnya.<\/p>\n<p>Satu catatan praktis buat LangChain dan LangGraph: pasang handler-nya lewat config saat invoke, bukan ditempel ke client LLM-nya, supaya handler itu menjalar ke seluruh graph secara otomatis. Dan bungkus pemanggilan framework itu dengan root span bikinanmu sendiri yang membawa <code>user_id<\/code>, <code>session_id<\/code>, dan metadata produk \u2014 framework-nya nggak tahu konteks bisnismu, kamulah yang harus menempelkannya.<\/p>\n<h2>Cloud vs self-host: pilih yang mana?<\/h2>\n<table>\n<tbody>\n<tr>\n<th><strong>Pertimbangan<\/strong><\/th>\n<th><strong>Langfuse Cloud<\/strong><\/th>\n<th><strong>Self-host<\/strong><\/th>\n<\/tr>\n<tr>\n<td>Mulai<\/td>\n<td>Daftar, bikin project, salin key \u2014 selesai<\/td>\n<td>Clone repo, <code>docker compose up<\/code>, sekitar 5 menit di satu VM<\/td>\n<\/tr>\n<tr>\n<td>Biaya lisensi<\/td>\n<td>Ada paket gratis Hobby; tier berbayar sesuai pemakaian unit<\/td>\n<td>Core gratis di bawah lisensi MIT, tanpa meteran pemakaian<\/td>\n<\/tr>\n<tr>\n<td>Data<\/td>\n<td>Di infrastruktur Langfuse, dengan pilihan region (EU, AS, Jepang, HIPAA)<\/td>\n<td>Seluruhnya di infrastruktur kamu sendiri<\/td>\n<\/tr>\n<tr>\n<td>Operasional<\/td>\n<td>Nggak ada yang perlu diurus<\/td>\n<td>Kamu yang mengoperasikan stack-nya: web, worker, PostgreSQL, ClickHouse, Redis, dan object storage<\/td>\n<\/tr>\n<tr>\n<td>Produksi serius<\/td>\n<td>Tinggal naik tier<\/td>\n<td>Jalur yang disarankan: Kubernetes pakai Helm; ada juga template Terraform buat AWS, Azure, dan GCP<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Paket gratis Hobby di Cloud mencakup puluhan ribu unit per bulan (unit dihitung dari trace, observation, dan score yang masuk), akses data 30 hari, dan 2 user \u2014 cukup buat proof-of-concept dan proyek kecil. Tier berbayarnya per November 2026 mulai dari puluhan dolar per bulan buat Core, ratusan buat Pro, dan ribuan buat Enterprise, dengan overage per unit. Angka-angka ini bisa berubah, jadi cek halaman pricing resmi sebelum bikin keputusan budget.<\/p>\n<p>Buat tim yang datanya nggak boleh keluar dari infrastruktur sendiri \u2014 misalnya karena regulasi atau kebijakan klien \u2014 self-host adalah jawabannya, dan ini salah satu alasan terbesar orang memilih Langfuse dibanding platform observability LLM yang hanya tersedia sebagai layanan tertutup.<\/p>\n<h2>Pertanyaan yang sering ditanya soal ini<\/h2>\n<h3>Apakah Langfuse cuma bisa dipakai bareng LangChain?<\/h3>\n<p>Nggak. Namanya memang mirip, tapi Langfuse berdiri sendiri dan bekerja dengan framework apa pun. Ada integrasi native buat LangChain, LangGraph, LlamaIndex, OpenAI, dan lain-lain, dan karena fondasinya OpenTelemetry, aplikasi apa pun yang sudah terinstrumentasi OTel bisa mengirim trace ke Langfuse.<\/p>\n<h3>Apakah Langfuse gratis?<\/h3>\n<p>Core-nya open-source di bawah lisensi MIT dan bisa di-self-host gratis tanpa batas pemakaian. Langfuse Cloud punya paket gratis Hobby dengan batas unit bulanan dan akses data 30 hari, lalu ada tier berbayar buat kebutuhan yang lebih besar. Selalu cek halaman pricing resmi buat angka terkininya.<\/p>\n<h3>Apa bedanya trace, span, dan generation?<\/h3>\n<p>Trace adalah satu request utuh dari awal sampai akhir. Span adalah satu langkah kerja di dalam trace, biasanya buat pekerjaan non-LLM kayak retrieval atau parsing. Generation adalah span khusus buat panggilan ke model, yang juga mencatat nama model, parameter, jumlah token, dan biaya.<\/p>\n<h3>Apakah Langfuse menambah latensi ke aplikasi?<\/h3>\n<p>Hampir tidak. SDK mengirim trace secara asinkron dalam batch, dan error di SDK ditangkap supaya aplikasimu nggak ikut jatuh. Yang perlu diingat: di script pendek, notebook, dan job batch, panggil <code>langfuse.flush()<\/code> sebelum proses selesai, supaya trace yang masih antre sempat kekirim.<\/p>\n<h3>Bisakah Langfuse dipakai dari bahasa selain Python dan JavaScript?<\/h3>\n<p>Bisa. Kamu bisa mengirim span OpenTelemetry dari SDK OTel bahasa apa pun \u2014 Java, Go, .NET, Ruby, PHP, Rust, dan lain-lain \u2014 ke endpoint OTel Langfuse, dan memakai public API buat fitur prompt management, evaluasi, dan query. Ada juga SDK komunitas buat beberapa bahasa.<\/p>\n<h3>Apakah prompt dan data user saya aman di Langfuse?<\/h3>\n<p>Tergantung deployment yang kamu pilih. Self-host berarti semua data tinggal di infrastrukturmu. Di Cloud, kamu bisa memilih region data. Buat data sensitif, decorator <code>@observe<\/code> punya opsi <code>capture_input=False<\/code> dan <code>capture_output=False<\/code> supaya argumen dan return value fungsi nggak ikut tercatat \u2014 dan kamu tetap bisa mengisi input\/output yang sudah disanitasi secara manual.<\/p>\n<h2>Agent tanpa observability itu debugging buta<\/h2>\n<p>Agent yang sudah sampai ke tangan user akan gagal dengan cara yang nggak pernah kamu duga waktu development. Bukan karena kodenya jelek, tapi karena input user itu liar, retrieval bisa meleset, dan model bisa berubah perilakunya tanpa pemberitahuan. Tanpa rekaman tiap langkah, setiap komplain berubah jadi sesi menebak yang makan waktu berjam-jam.<\/p>\n<p>Langfuse nggak bikin agent kamu lebih pintar. Yang dia kasih adalah kemampuan buat melihat \u2014 langkah mana yang salah, prompt versi berapa yang jalan, berapa biayanya, dan apakah kualitasnya membaik atau memburuk dari waktu ke waktu. Itu fondasi yang bikin semua perbaikan berikutnya jadi mungkin.<\/p>\n<p>Mulainya nggak perlu besar. Pasang SDK-nya di satu endpoint, kirim satu trace, buka dashboard-nya, dan lihat sendiri pohon eksekusi agent kamu buat pertama kalinya. Dari situ, session, score, dan prompt management tinggal ditambah satu per satu sesuai kebutuhan.<\/p>\n<p>Kamu sendiri gimana? Agent kamu sudah pernah jawab ngawur di produksi padahal log-nya bersih? Ceritain di kolom komentar \u2014 aku pengin tahu kegagalan paling aneh apa yang pernah kamu temuin, dan gimana akhirnya ketemu akar masalahnya.<\/p>\n<h2>Sumber dan bacaan lanjutan<\/h2>\n<ul>\n<li>Dokumentasi resmi Langfuse: <em><a href=\"https:\/\/langfuse.com\/docs\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/docs<\/a><\/em><\/li>\n<li>SDK observability Python &amp; JS\/TS (setup, environment variable, model data OpenTelemetry): <em><a href=\"https:\/\/langfuse.com\/docs\/observability\/sdk\/overview\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/docs\/observability\/sdk\/overview<\/a><\/em><\/li>\n<li>Sessions \u2014 grouping trace dan session replay: <em><a href=\"https:\/\/langfuse.com\/docs\/observability\/features\/sessions\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/docs\/observability\/features\/sessions<\/a><\/em><\/li>\n<li>Token &amp; cost tracking \u2014 usage details, cost details, dan definisi model: <em><a href=\"https:\/\/langfuse.com\/docs\/observability\/features\/token-and-cost-tracking\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/docs\/observability\/features\/token-and-cost-tracking<\/a><\/em><\/li>\n<li>Prompt management at scale \u2014 versi, label, dan caching: <em><a href=\"https:\/\/langfuse.com\/resources\/engineering\/prompt-management-at-scale\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/resources\/engineering\/prompt-management-at-scale<\/a><\/em><\/li>\n<li>Clarifications \u2014 skor, evaluasi, alert, dashboard, dan paket Hobby: <em><a href=\"https:\/\/langfuse.com\/resources\/engineering\/clarifications\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/resources\/engineering\/clarifications<\/a><\/em><\/li>\n<li>Self-hosting \u2014 Docker Compose, Kubernetes, dan template Terraform: <em><a href=\"https:\/\/langfuse.com\/self-hosting\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/self-hosting<\/a><\/em><\/li>\n<li>Referensi API Python SDK: <em><a href=\"https:\/\/python.reference.langfuse.com\/langfuse\" target=\"_blank\" rel=\"noopener\">https:\/\/python.reference.langfuse.com\/langfuse<\/a><\/em><\/li>\n<li>Repositori GitHub langfuse\/langfuse: <em><a href=\"https:\/\/github.com\/langfuse\/langfuse\" target=\"_blank\" rel=\"noopener\">https:\/\/github.com\/langfuse\/langfuse<\/a><\/em><\/li>\n<li>Halaman pricing resmi Langfuse Cloud: <em><a href=\"https:\/\/langfuse.com\/pricing\" target=\"_blank\" rel=\"noopener\">https:\/\/langfuse.com\/pricing<\/a><\/em><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Panduan Langfuse: lacak log, latensi, dan biaya AI agent di produksi, plus cara debugging lewat trace, session, dan score.<\/p>\n","protected":false},"author":1,"featured_media":3136,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[5],"tags":[],"class_list":["post-3135","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-agent"],"acf":[],"_links":{"self":[{"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/posts\/3135","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/comments?post=3135"}],"version-history":[{"count":3,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/posts\/3135\/revisions"}],"predecessor-version":[{"id":3139,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/posts\/3135\/revisions\/3139"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/media\/3136"}],"wp:attachment":[{"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/media?parent=3135"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/categories?post=3135"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/komunitech.com\/blog\/wp-json\/wp\/v2\/tags?post=3135"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}