Helicone: Cara Aku Memonitor dan Mengontrol Semua LLM Call di Produksi

Temen-temen, kalau kalian sudah mulai serius bangun aplikasi berbasis LLM, entah itu chatbot, agent, atau fitur AI di dalam produk, cepat atau lambat kalian bakal ketemu satu masalah yang sama: kalian nggak tahu apa yang sebenarnya terjadi di balik setiap panggilan ke model. Berapa token yang kepakai? Berapa biayanya bulan ini? Kenapa request ini lambat banget? User mana yang paling sering nge-hit API? Prompt versi mana yang bikin cost membengkak? Semua pertanyaan itu susah dijawab kalau kalian cuma nembak openai.chat.completions.create() terus lupain begitu saja.

Nah, di tutorial ini aku mau kenalin kalian ke Helicone. Helicone itu platform observability open-source khusus buat LLM. Tugas utamanya sederhana tapi krusial: dia mencatat (logging), memonitor, dan ngasih kalian kontrol penuh atas setiap LLM call yang aplikasi kalian kirim. Yang bikin aku suka, cara pakainya nggak ribet. Kalian cukup ganti baseurl ke proxy Helicone dan tambahin satu header autentikasi, dan tiba-tiba semua request kalian ke-log rapi di dashboard. Nggak perlu rombak arsitektur, nggak perlu install SDK berat, nggak perlu ubah logika bisnis.

Sepanjang tutorial ini aku bakal ajak kalian dari nol: mulai dari setup akun dan integrasi paling dasar, cara logging request, nambahin custom properties, tracking per-user, caching biar hemat biaya, rate limiting biar user nggak nakal, sampai ke sessions dan tracing buat agent yang punya banyak langkah. Semua contoh aku kasih pakai Python dengan OpenAI SDK, karena itu kombinasi yang paling umum dipakai. Yuk kita mulai.

Introduction

Sebelum masuk ke kode, aku mau kalian paham dulu kenapa observability itu penting dan gimana Helicone menyelesaikannya.

Waktu aplikasi LLM kalian masih di tahap prototipe, semuanya kelihatan baik-baik saja. Kalian ngetik prompt, dapat jawaban, senang. Tapi begitu masuk produksi dengan ratusan atau ribuan user, situasinya berubah total. Biaya API bisa naik nggak terkendali karena ada prompt yang kepanjangan. Ada request yang gagal diam-diam dan user komplain. Latency naik pas jam sibuk dan kalian nggak tahu penyebabnya. Tanpa observability, kalian terbang buta.

Helicone menyelesaikan ini dengan dua pendekatan integrasi:

• Proxy (Gateway): Kalian arahkan request LLM lewat proxy Helicone. Ini cara paling cepat, cukup ganti baseurl. Karena request lewat Helicone, dia bisa nambahin fitur seperti caching dan rate limiting di level jaringan.
• Async Logging: Kalau kalian nggak mau request lewat proxy (misalnya karena alasan latency atau kebijakan keamanan), kalian bisa kirim log secara asinkron ke Helicone setelah request selesai. Model panggilan LLM tetap langsung ke OpenAI, log dikirim terpisah.

Untuk kebanyakan kasus, pendekatan proxy itu yang paling praktis dan itu yang bakal aku fokusin di sini. Alasannya, dengan proxy kalian dapat semua fitur sekaligus tanpa nulis kode tambahan yang banyak.

Yang bikin Helicone menarik dibanding sekadar nyimpan log sendiri di database:

• Dashboard biaya dan latency yang langsung jadi. Kalian bisa lihat total spend, breakdown per model, per user, per fitur.
• Custom properties buat nge-tag setiap request supaya bisa difilter dan dianalisa nanti.
• Caching built-in yang bisa hemat biaya drastis buat request yang berulang.
• Rate limiting per user atau per properti, tanpa kalian harus bangun sistem sendiri.
• Sessions dan tracing buat agent yang punya banyak langkah, jadi kalian bisa lihat alur eksekusi utuh dari awal sampai akhir.

Dan karena open-source, kalian bisa self-host kalau memang mau kontrol penuh atas data. Tapi buat mulai, versi cloud gratisnya sudah lebih dari cukup.

Instalasi

Kabar baiknya, buat pakai Helicone dengan pendekatan proxy, kalian sebenarnya nggak perlu install package Helicone sama sekali. Kalian cukup punya OpenAI SDK yang sudah kalian pakai. Tapi biar lengkap, aku jelasin semua yang kalian butuhin.

Langkah 1: Bikin Akun dan Ambil API Key

Pertama, daftar di helicone.ai pakai email atau akun GitHub. Setelah masuk, buka menu Settings lalu bagian API Keys. Generate satu key baru, biasanya formatnya diawali dengan sk-helicone-. Simpan key ini baik-baik, jangan sampai bocor ke repo publik.

Langkah 2: Install Dependency

Yang wajib cuma OpenAI SDK:

pip install openai

Kalau kalian mau pakai Python SDK khusus Helicone (buat async logging manual atau fitur advance tertentu), install ini juga:

pip install helicone-helpers

Tapi untuk sebagian besar tutorial ini, openai saja sudah cukup karena kita pakai proxy.

Langkah 3: Simpan Kredensial di Environment Variable

Jangan pernah hardcode API key di dalam kode. Aku selalu simpan di environment variable atau file .env. Bikin file .env:

OPENAIAPIKEY=sk-proj-xxxxxxxxxxxxxxxx
HELICONEAPIKEY=sk-helicone-xxxxxxxxxxxxxxxx

Lalu buat baca file .env ini di Python, install python-dotenv:

pip install python-dotenv

Sekarang kalian sudah siap. Nggak ada yang ribet kan? Ayo kita masuk ke penggunaan dasarnya.

Basic Usage

Di bagian ini aku bakal tunjukin cara paling inti pakai Helicone: mengarahkan OpenAI SDK lewat proxy Helicone supaya semua request otomatis ke-log.

Integrasi Proxy Paling Dasar

Kuncinya cuma dua hal: ganti baseurl ke endpoint proxy Helicone, dan tambahin header Helicone-Auth. Perhatikan kode berikut:

import os
from dotenv import loaddotenv
from openai import OpenAI

loaddotenv()


client = OpenAI(
    apikey=os.environ["OPENAIAPIKEY"],
    baseurl="https://oai.helicone.ai/v1",

    defaultheaders={
        "Helicone-Auth": f"Bearer {os.environ['HELICONEAPIKEY']}",
    },
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Kamu asisten yang ramah dan ringkas."},
        {"role": "user", "content": "Jelaskan apa itu observability dalam satu kalimat."},
    ],
)

print(response.choices[0].message.content)

Coba perhatikan, satu-satunya perbedaan dari kode OpenAI biasa cuma dua baris: baseurl dan defaultheaders. Sisanya sama persis seperti yang biasa kalian tulis. Begitu kode ini jalan, buka dashboard Helicone dan kalian bakal lihat request-nya muncul lengkap dengan prompt, response, jumlah token, biaya, dan latency. Ini yang aku maksud "gampang banget". Kalian nggak ngubah logika apa pun, cuma ngasih tahu OpenAI SDK supaya lewat Helicone dulu.

Memahami Apa yang Di-log

Setiap request yang lewat proxy otomatis nyimpan informasi ini di dashboard:

• Request dan response body lengkap, jadi kalian bisa lihat prompt dan jawaban aslinya.
• Model yang dipakai.
• Token usage: prompt tokens, completion tokens, total.
• Cost: Helicone hitung otomatis biaya berdasarkan harga model.
• Latency: berapa lama request selesai.
• Status: sukses atau error, plus kode errornya kalau gagal.

Semua ini kalian dapat gratis tanpa nulis kode logging manual satu baris pun.

Alternatif: Async Logging Tanpa Proxy

Kalau kalian punya alasan buat nggak lewat proxy, kalian bisa pakai async logging. Di sini panggilan LLM tetap langsung ke OpenAI, dan log dikirim terpisah ke Helicone. Ini contoh sederhananya pakai HTTP request manual ke endpoint logging Helicone:

import os
import time
import requests
from dotenv import loaddotenv

from openai import OpenAI

loaddotenv()

Panggilan LLM langsung ke OpenAI, tanpa proxy
client = OpenAI(apikey=os.environ["OPENAIAPIKEY"])


start = time.time()
messages = [{"role": "user", "content": "Apa ibukota Indonesia?"}]
response = client.chat.completions.create(model="gpt-4o-mini", messages=messages)
latencyms = int((time.time() - start) * 1000)

Kirim log ke Helicone secara terpisah
logpayload = {

    "providerRequest": {
        "url": "https://api.openai.com/v1/chat/completions",
        "json": {"model": "gpt-4o-mini", "messages": messages},
        "meta": {},
    },
    "providerResponse": {
        "json": response.modeldump(),
        "status": 200,
        "headers": {},
    },
    "timing": {"startTime": {"seconds": int(start)}, "endTime": {"seconds": int(time.time())}},
}

requests.post(
    "https://api.helicone.ai/oai/v1/log",
    headers={"Authorization": f"Bearer {os.environ['HELICONEAPIKEY']}"},
    json=logpayload,

    timeout=10,
)

print(response.choices[0].message.content)

Jujur, pendekatan async ini lebih ribet dan biasanya aku cuma pakai kalau ada kebutuhan khusus soal keamanan atau latency. Untuk hampir semua kasus, proxy jauh lebih simpel. Jadi mulai sekarang aku bakal pakai pendekatan proxy terus.

Menyederhanakan dengan Helper Function

Biar nggak nulis konfigurasi client berulang-ulang, aku suka bikin satu helper function yang bikin client Helicone:

import os
from openai import OpenAI

def getheliconeclient(extraheaders=None):
    headers = {
        "Helicone-Auth": f"Bearer {os.environ['HELICONEAPIKEY']}",
    }
    if extraheaders:

        headers.update(extraheaders)
    return OpenAI(
        apikey=os.environ["OPENAIAPIKEY"],

        baseurl="https://oai.helicone.ai/v1",
        defaultheaders=headers,

    )

client = getheliconeclient()

Dengan pola ini, aku bisa gampang nambahin header tambahan seperti custom properties atau user id yang bakal kita bahas sebentar lagi.

Advanced Usage

Oke temen-temen, sampai sini kalian sudah bisa logging dasar. Sekarang kita masuk ke bagian yang bikin Helicone benar-benar powerful. Semua fitur di bawah ini diaktifkan lewat header, jadi polanya konsisten dan gampang diingat.

Custom Properties untuk Tagging dan Segmentasi

Custom properties itu label yang kalian tempel ke setiap request. Gunanya buat memfilter dan menganalisa data di dashboard. Misalnya kalian mau tahu fitur mana yang paling banyak makan biaya, atau environment mana (production vs staging) yang generate request terbanyak. Kalian tinggal kirim header dengan prefix Helicone-Property-.

import os
from openai import OpenAI

client = OpenAI(
    apikey=os.environ["OPENAIAPIKEY"],
    baseurl="https://oai.helicone.ai/v1",

    defaultheaders={
        "Helicone-Auth": f"Bearer {os.environ['HELICONEAPIKEY']}",
    },
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Ringkas artikel ini menjadi 3 poin."}],
    extraheaders={

        "Helicone-Property-Feature": "summarizer",
        "Helicone-Property-Environment": "production",
        "Helicone-Property-Version": "v2",
    },
)

print(response.choices[0].message.content)

Perhatikan aku pakai extraheaders di level panggilan, bukan di client. Ini penting, karena properties biasanya berbeda per request. Helicone-Property-Feature bakal jadi kolom "Feature" di dashboard yang bisa kalian filter. Nama setelah Helicone-Property- bebas kalian tentukan sendiri. Aku biasanya konsisten pakai beberapa properti standar seperti Feature, Environment, dan Version di semua request supaya analisanya rapi.

User Tracking

Kalau aplikasi kalian punya banyak user, kalian pasti pengin tahu siapa yang paling aktif dan berapa biaya per user. Helicone punya header khusus buat ini, yaitu Helicone-User-Id.

def chatforuser(client, userid, prompt):
    return client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        extraheaders={
            "Helicone-User-Id": userid,

        },
    )

Contoh pemakaian
resp = chatforuser(client, "user12345", "Bantu aku bikin caption Instagram.")
print(resp.choices[0].message.content)

Dengan Helicone-User-Id, dashboard bakal punya halaman khusus per user. Kalian bisa lihat total request, total cost, dan pola pemakaian tiap user. Ini berguna banget kalau kalian jualan produk berbasis usage, karena kalian bisa hitung margin per user dengan akurat. Aku sarankan pakai id yang stabil dan anonim, misalnya id user dari database kalian, bukan email langsung, demi privasi.

Caching untuk Menghemat Biaya

Ini salah satu fitur favoritku. Banyak aplikasi mengirim request yang sama berulang-ulang. Contohnya, kalau ada 100 user nanya pertanyaan FAQ yang sama persis, ngapain kalian bayar 100 kali ke OpenAI? Helicone bisa cache response di level proxy. Aktifin dengan header Helicone-Cache-Enabled.

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Apa itu machine learning?"}],
    extraheaders={

        "Helicone-Cache-Enabled": "true",
        "Helicone-Cache-Bucket-Max-Size": "3",
        "Cache-Control": "max-age=3600",
    },
)

print(response.choices[0].message.content)

Penjelasan header di atas:

• Helicone-Cache-Enabled: true mengaktifkan caching buat request ini.
• Helicone-Cache-Bucket-Max-Size: 3 menentukan berapa banyak response berbeda yang disimpan per bucket. Berguna kalau kalian mau sedikit variasi jawaban.
• Cache-Control: max-age=3600 mengatur berapa lama cache valid, dalam detik. Di sini 3600 berarti satu jam.

Request pertama bakal jalan normal ke OpenAI. Request kedua dengan prompt identik dalam periode cache bakal langsung dilayani dari cache, jauh lebih cepat dan gratis. Di dashboard, kalian bisa lihat berapa banyak "cache hits" dan berapa uang yang kalian hemat. Buat aplikasi dengan banyak query berulang, penghematannya bisa signifikan. Tapi hati-hati, jangan pakai caching buat request yang emang harus selalu fresh, misalnya yang bergantung waktu atau data real-time.

Rate Limiting

Kadang ada user yang, entah sengaja atau nggak, ngirim request kebanyakan sampai bikin biaya kalian meledak. Helicone bisa nge-rate-limit di level proxy tanpa kalian bangun sistem sendiri. Kalian atur lewat header Helicone-RateLimit-Policy.

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Halo!"}],
    extraheaders={
        "Helicone-User-Id": "user12345",

        # Maksimal 100 request per 3600 detik (1 jam), dihitung per user
        "Helicone-RateLimit-Policy": "100;w=3600;s=user",
    },
)

Format policy-nya adalah [quota];w=[window detik];s=[segment]. Di contoh ini artinya maksimal 100 request per jam per user. Segment s=user bikin limit dihitung per Helicone-User-Id. Kalian juga bisa segment berdasarkan custom property. Kalau limit terlampaui, Helicone bakal balikin response dengan status 429 (Too Many Requests), dan kalian tinggal tangani itu di kode kalian.

from openai import RateLimitError

try:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "Halo lagi!"}],
        extraheaders={
            "Helicone-User-Id": "user12345",

            "Helicone-RateLimit-Policy": "100;w=3600;s=user",
        },
    )
    print(response.choices[0].message.content)
except RateLimitError:
    print("Kamu sudah mencapai batas pemakaian. Coba lagi nanti ya.")

Cost dan Latency Dashboard

Semua fitur di atas mengalir ke dashboard Helicone, dan di sinilah kalian benar-benar merasakan manfaatnya. Tanpa nulis kode apa pun, kalian dapat visualisasi:

• Total cost per hari, minggu, atau bulan, dengan breakdown per model.
• Latency distribution: median, p95, p99, jadi kalian tahu seberapa buruk pengalaman user paling lambat.
• Request volume dari waktu ke waktu, buat lihat pola trafik.
• Filter berdasarkan custom property atau user, jadi kalian bisa jawab pertanyaan seperti "fitur summarizer di production makan biaya berapa bulan ini?"

Yang aku suka, semua metrik ini bisa difilter kombinasi. Misalnya "tunjukin latency p95 untuk fitur chat di environment production untuk user premium". Data sedetail itu tanpa kalian bangun pipeline analytics sendiri, itu penghematan waktu engineering yang luar biasa.

Sessions dan Tracing untuk Agent

Nah ini bagian penting kalau kalian bangun agent. Agent itu biasanya melakukan banyak LLM call berurutan: mikir, panggil tool, mikir lagi, jawab. Kalau tiap call ke-log terpisah, kalian susah lihat alur utuhnya. Helicone punya konsep sessions yang mengelompokkan semua request yang berkaitan menjadi satu trace.

Kalian pakai tiga header:

• Helicone-Session-Id: id unik untuk satu sesi percakapan atau satu jalannya agent.
• Helicone-Session-Name: nama sesi biar gampang dikenali.
• Helicone-Session-Path: menunjukkan posisi request dalam hierarki trace, seperti path folder.

import uuid

sessionid = str(uuid.uuid4())

def agentstep(client, sessionid, path, prompt):
    return client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        extraheaders={

            "Helicone-Session-Id": sessionid,
            "Helicone-Session-Name": "Riset Agent",
            "Helicone-Session-Path": path,
        },
    )

Langkah 1: agent merencanakan
plan = agentstep(client, sessionid, "/plan",
                  "Buat rencana untuk meneliti tren AI 2026.")

Langkah 2: agent mengeksekusi salah satu sub-tugas
research = agentstep(client, sessionid, "/plan/research",
                      "Cari 3 tren AI paling penting di 2026.")

Langkah 3: agent menyusun kesimpulan
summary = agentstep(client, sessionid, "/plan/summary",
                     "Rangkum temuan risetnya jadi paragraf singkat.")

print(summary.choices[0].message.content)

Karena ketiga call pakai Helicone-Session-Id yang sama, dashboard bakal menampilkan mereka sebagai satu trace pohon. Helicone-Session-Path yang berbentuk /plan, /plan/research, /plan/summary bikin Helicone bisa gambar hierarki mana yang anak dari mana. Ini bikin debugging agent jauh lebih enak. Kalau ada agent yang ngasih output aneh, kalian bisa telusuri langkah demi langkah persis di mana logikanya melenceng, lengkap dengan prompt dan response tiap langkah.

Best Practices

Setelah cukup lama pakai Helicone di beberapa proyek, ada beberapa hal yang aku pelajari dan mau aku bagi ke kalian supaya kalian nggak kejeblos di lubang yang sama.

Konsisten dengan Skema Custom Properties

Tentukan satu set custom properties standar sejak awal dan pakai konsisten di seluruh aplikasi. Aku biasanya minimal pakai Feature, Environment, dan Version. Kalau tiap developer bikin nama properti sendiri-sendiri, dashboard kalian bakal berantakan dan susah difilter. Bikin helper function terpusat yang otomatis nambahin properti wajib ini di setiap request supaya nggak ada yang kelupaan.

Jangan Cache Sembarangan

Caching itu ampuh buat hemat biaya, tapi jangan asal aktifin di semua request. Request yang bergantung pada waktu, data user spesifik, atau butuh variasi kreatif jangan di-cache. Aku biasanya cuma cache request yang deterministik dan berulang, seperti FAQ, klasifikasi, atau ekstraksi yang inputnya sering identik. Selalu set Cache-Control dengan durasi yang masuk akal sesuai seberapa cepat data kalian berubah.

Selalu Set User Id di Produksi

Selalu kirim Helicone-User-Id di lingkungan produksi. Tanpa ini, kalian kehilangan kemampuan menganalisa biaya dan pemakaian per user, dan itu data yang sangat berharga buat keputusan bisnis. Pakai id anonim yang stabil dari database kalian, jangan email atau data pribadi, demi privasi user.

Manfaatkan Sessions untuk Semua Alur Multi-Step

Setiap kali kalian punya alur yang melibatkan lebih dari satu LLM call yang berkaitan, bungkus dengan session id yang sama. Ini bukan cuma buat agent, tapi juga buat percakapan chatbot multi-turn atau pipeline yang punya beberapa tahap. Trace yang rapi bakal menyelamatkan waktu debugging kalian berkali-kali lipat di masa depan.

Tangani Error dengan Baik

Karena request lewat proxy, ada kemungkinan kecil proxy bermasalah atau rate limit kena. Selalu bungkus panggilan LLM dengan try-except yang menangani RateLimitError dan error jaringan. Untuk aplikasi yang benar-benar kritis, aku kadang siapin fallback yang langsung ke OpenAI tanpa proxy kalau proxy Helicone lagi down, supaya layanan tetap jalan sementara observability sementara mati.

Amankan API Key

Ini basic tapi sering dilupakan. Jangan pernah hardcode HELICONEAPIKEY atau OPENAIAPIKEY di kode yang masuk repo. Selalu pakai environment variable. Kalau key bocor, segera rotate dari dashboard Helicone dan OpenAI.

Pertimbangkan Self-Hosting untuk Data Sensitif

Kalau kalian bekerja dengan data yang sangat sensitif atau ada regulasi ketat, ingat bahwa Helicone open-source dan bisa di-self-host. Dengan begitu semua log tetap di infrastruktur kalian sendiri. Buat sebagian besar startup, versi cloud sudah aman dan praktis, tapi opsi self-host itu ada kalau kalian butuh.

Conclusion

Sampai di sini temen-temen, kita sudah keliling cukup jauh. Kita mulai dari memahami kenapa observability LLM itu penting, lalu setup Helicone yang ternyata cuma butuh ganti base_url dan nambah satu header autentikasi. Dari situ kita belajar logging dasar, nempel custom properties buat segmentasi, tracking per user, caching buat hemat biaya, rate limiting biar aman dari abuse, membaca dashboard cost dan latency, sampai sessions dan tracing buat men-debug agent yang punya banyak langkah.

Yang aku harap kalian bawa pulang dari tutorial ini adalah kesadaran bahwa aplikasi LLM di produksi butuh mata dan telinga. Kalian nggak bisa mengelola apa yang nggak kalian ukur. Helicone ngasih kalian semua alat ukur itu dengan effort integrasi yang minim banget. Buat aku pribadi, rasio antara betapa mudah setup-nya dengan betapa banyak insight yang aku dapat itu salah satu yang terbaik di antara tools sejenis.

Saranku, mulai dari yang kecil dulu. Aktifin proxy dan logging dasar di satu fitur, lihat datanya di dashboard, lalu pelan-pelan tambahin custom properties, user id, dan caching seiring kebutuhan kalian bertumbuh. Nggak perlu langsung pakai semua fitur sekaligus. Yang penting kalian mulai punya visibilitas atas apa yang aplikasi kalian lakukan di balik layar.

Selamat mencoba, dan semoga aplikasi AI kalian makin hemat, cepat, dan terkontrol. Kalau kalian sudah mainan Helicone, coba deh eksplor juga fitur-fitur lain di dashboard-nya yang belum aku bahas di sini, karena masih banyak yang bisa digali. Sampai ketemu di tutorial berikutnya, temen-temen.