Tutorial Lengkap Braintrust: Evaluasi, Testing, dan Improve Aplikasi LLM

Halo temen-temen, di tutorial kali ini aku mau ngajak kalian kenalan sama satu platform yang menurutku bakal ngubah cara kalian ngembangin aplikasi LLM secara serius, namanya Braintrust. Kalau kalian pernah bikin fitur berbasis LLM terus bingung gimana caranya tau apakah perubahan prompt yang baru itu beneran lebih bagus atau malah bikin tambah jelek, nah Braintrust ini jawabannya. Aku sendiri udah beberapa kali kejebak di situasi kayak gitu. Ganti prompt, ganti model, ganti temperature, terus cuma bisa nebak-nebak apakah hasilnya membaik. Rasanya kayak nyetir sambil merem.

Braintrust ini pada dasarnya adalah platform buat evaluasi, testing, dan improve aplikasi LLM. Jadi dia bantu kalian ngukur kualitas output model secara objektif, bukan cuma pakai feeling. Di artikel ini aku bakal bahas dari nol, mulai dari konsep-konsep intinya kayak experiment, dataset, scorer atau eval, dan logging, terus lanjut ke instalasi, cara nulis fungsi Eval() yang lengkap, cara ngebandingin dua versi prompt, cara logging trace dari produksi, sampai fitur prompt playground yang seru banget. Aku bakal kasih banyak contoh kode Python pakai library braintrust dan autoevals. Yuk kita mulai.

Kenapa Kita Butuh Evaluasi buat Aplikasi LLM

Sebelum masuk ke Braintrust, aku mau cerita dulu kenapa evaluasi itu penting banget di dunia LLM. Beda sama kode biasa yang deterministik, output LLM itu probabilistik. Input yang sama bisa ngasih output yang beda-beda. Jadi kalian gak bisa nulis unit test biasa yang bilang "output harus sama persis dengan ini". Output-nya bisa bener secara makna tapi kata-katanya beda.

Nah masalahnya, waktu kalian ngembangin aplikasi LLM, kalian bakal terus-terusan ngoprek. Ganti prompt biar lebih jelas, ganti model dari yang murah ke yang mahal atau sebaliknya, nambahin few-shot example, ngatur temperature, dan seterusnya. Tiap perubahan itu bisa bikin sebagian kasus jadi lebih baik tapi sebagian lain malah jadi lebih buruk. Tanpa alat ukur yang bener, kalian gak akan pernah tau trade-off-nya.

Pendekatan naif biasanya kita coba beberapa contoh secara manual, liat outputnya, terus bilang "oke kayaknya udah bagus nih". Tapi ini bahaya banget temen-temen. Kalian cuma nyoba lima sampai sepuluh contoh, padahal di produksi ada ribuan variasi input. Bisa jadi perubahan yang keliatannya bagus di contoh kalian malah bikin rusak di kasus yang gak kalian tes. Ini yang sering disebut "vibes-based development", ngembangin cuma modal feeling.

Braintrust ngasih kita cara buat ngukur ini secara sistematis. Idenya simpel. Kita kumpulin sekumpulan input beserta jawaban idealnya, kita jalanin aplikasi kita ke input-input itu, terus kita kasih skor tiap output pakai fungsi penilai. Hasilnya kita simpan sebagai satu experiment. Begitu kita ubah sesuatu, kita jalanin lagi dan bandingin experiment yang baru sama yang lama. Sekarang kita punya angka konkret buat ngeliat apakah perubahan kita beneran ningkatin kualitas atau enggak.

Konsep Inti Braintrust

Sebelum ngoding, penting banget buat ngerti empat konsep utama di Braintrust. Kalau kalian paham empat ini, sisanya bakal gampang.

Yang pertama adalah dataset. Dataset itu kumpulan contoh yang kalian pakai buat evaluasi. Tiap contoh biasanya punya input (apa yang dikasih ke aplikasi) dan expected (jawaban ideal atau ground truth). Dataset ini yang jadi tolok ukur kalian. Semakin representatif dataset kalian sama kondisi produksi, semakin akurat evaluasinya.

Yang kedua adalah task. Task itu fungsi aplikasi kalian yang mau dievaluasi. Dia nerima input dan ngembaliin output. Isinya bisa apa aja, mulai dari sekadar manggil satu LLM sampai pipeline RAG yang kompleks. Braintrust gak peduli isi task-nya apa, yang penting dia bisa nerima input dan ngasih output.

Yang ketiga adalah scorer atau sering juga disebut eval. Ini fungsi yang ngasih nilai ke output task kalian, biasanya angka dari 0 sampai 1. Scorer bisa bermacam-macam. Ada yang deterministik kayak ngecek apakah output sama persis sama expected, ada yang berbasis heuristik kayak ngukur kemiripan teks, dan ada juga yang canggih pakai LLM buat menilai output (ini yang disebut LLM-as-a-judge). Library autoevals bawaan Braintrust nyediain banyak scorer siap pakai.

Yang keempat adalah experiment. Experiment itu satu kali eksekusi evaluasi lengkap. Waktu kalian jalanin task ke seluruh dataset dan ngasih skor tiap outputnya, hasilnya kekumpul jadi satu experiment. Tiap experiment punya skor agregat, dan kalian bisa bandingin experiment satu sama lain buat ngeliat regresi atau perbaikan.

Selain empat itu, ada juga konsep logging buat produksi. Kalau evaluasi itu buat sebelum rilis, logging itu buat memantau aplikasi kalian yang udah jalan di produksi. Kalian catat tiap request dan response beserta metadata dan trace-nya, biar bisa dianalisis dan bahkan dijadiin dataset baru buat evaluasi. Jadi ada siklus yang bagus di sini, dari produksi balik lagi ke evaluasi.

Instalasi

Oke sekarang kita mulai praktik. Instalasinya gampang banget, cukup pakai pip. Kalian butuh dua package utama, yaitu braintrust sendiri dan autoevals buat scorer siap pakai.

pip install braintrust autoevals

Kalau kalian bakal manggil LLM langsung di dalam task, kalian juga butuh library provider-nya. Aku biasanya install sekalian OpenAI karena banyak contoh pakai itu.

pip install braintrust autoevals openai

Kayak biasa, aku saranin banget pakai virtual environment biar dependency project kalian gak campur aduk. Aktifin dulu venv sebelum install.

python -m venv venv
source venv/bin/activate  # kalau di Windows: venv\Scripts\activate
pip install braintrust autoevals openai

Setelah kepasang, kalian butuh API key dari Braintrust. Daftar dulu di dashboard Braintrust, terus bikin API key di halaman setting. Simpan key itu sebagai environment variable biar aman dan gak kehardcode di kode.

export BRAINTRUSTAPIKEY="sk-braintrust-key-kalian"
export OPENAIAPIKEY="sk-openai-key-kalian"

Buat ngetes apakah instalasinya udah bener, kalian bisa coba import library-nya di Python.

import braintrust
import autoevals

print("Braintrust siap dipakai")

Kalau gak ada error, berarti kalian udah siap masuk ke bagian yang seru.

Penggunaan Dasar: Nulis Eval Pertama

Nah sekarang kita masuk ke inti Braintrust, yaitu fungsi Eval(). Fungsi ini yang jadi jantung dari semua evaluasi. Dia butuh tiga hal utama sesuai konsep yang tadi kita bahas, yaitu dataset (data), task, dan scorer (scores).

Ayo kita bikin contoh sederhana dulu. Misalnya aku punya aplikasi yang tugasnya jawab pertanyaan pengetahuan umum. Aku pengen ngukur seberapa sering aplikasiku ngasih jawaban yang bener.

from braintrust import Eval
from autoevals import Levenshtein

def mytask(input):

    # ini task sederhana, cuma dictionary jawaban.
    # di dunia nyata ini bakal manggil LLM.
    jawaban = {
        "Ibu kota Indonesia?": "Jakarta",
        "Berapa 2 tambah 2?": "4",
        "Warna langit di siang hari?": "Biru",
    }
    return jawaban.get(input, "Tidak tahu")

Eval(
    "aplikasi-qa-pertama",  # nama project
    data=lambda: [
        {"input": "Ibu kota Indonesia?", "expected": "Jakarta"},
        {"input": "Berapa 2 tambah 2?", "expected": "4"},
        {"input": "Warna langit di siang hari?", "expected": "Biru"},
    ],
    task=mytask,
    scores=[Levenshtein],
)

Coba kita bedah kode di atas satu-satu ya temen-temen. Argumen pertama "aplikasi-qa-pertama" itu nama project di Braintrust. Semua experiment kalian bakal kekumpul di bawah project ini.

Argumen data itu fungsi yang ngembaliin list contoh. Tiap contoh punya input dan expected. Aku sengaja pakai lambda biar datanya diambil pas dibutuhin. Kalian bisa juga langsung kasih list, tapi pakai fungsi lebih fleksibel kalau datanya perlu di-load dari file atau API.

Argumen task itu fungsi aplikasi kita. Braintrust bakal manggil fungsi ini buat tiap input di dataset, terus nyimpen output-nya.

Argumen scores itu list scorer. Di sini aku pakai Levenshtein dari autoevals, yang ngukur kemiripan teks antara output sama expected berdasarkan jarak edit. Skornya dari 0 (beda total) sampai 1 (sama persis).

Buat ngejalaninnya, simpan kode itu di file misalnya evalqa.py, terus jalanin pakai perintah braintrust eval.

braintrust eval evalqa.py

Braintrust bakal ngejalanin task ke seluruh dataset, ngasih skor tiap output, terus ngasih kalian link ke dashboard. Di dashboard itu kalian bisa liat skor rata-rata, detail tiap contoh, output apa yang keluar, dan skornya berapa. Ini pengalaman yang beda banget dibanding cuma print-print di terminal.

Task yang Manggil LLM Beneran

Contoh tadi task-nya masih pura-pura. Sekarang kita bikin task yang beneran manggil LLM. Braintrust punya wrapper buat client OpenAI biar semua panggilan otomatis ke-log.

from braintrust import Eval, wrapopenai
from autoevals import Factuality
from openai import OpenAI

client = wrapopenai(OpenAI())

def qatask(input):

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Jawab singkat dan akurat."},
            {"role": "user", "content": input},
        ],
    )
    return response.choices[0].message.content

Eval(
    "aplikasi-qa-llm",
    data=lambda: [
        {"input": "Apa ibu kota Jepang?", "expected": "Tokyo"},
        {"input": "Siapa penulis novel Laskar Pelangi?", "expected": "Andrea Hirata"},
        {"input": "Berapa jumlah planet di tata surya?", "expected": "Delapan"},
    ],
    task=qatask,
    scores=[Factuality],
)

Perhatiin di sini aku pakai wrapopenai buat bungkus client OpenAI. Ini penting karena bikin tiap panggilan LLM otomatis kecatat lengkap sama input, output, token yang dipakai, dan latency-nya. Jadi di dashboard kalian bisa liat detail tiap panggilan.

Buat scorer aku ganti ke Factuality. Ini scorer berbasis LLM yang ngecek apakah output secara faktual konsisten sama expected. Bedanya sama Levenshtein, Factuality gak peduli kata-katanya sama persis atau enggak, yang penting maknanya bener. Jadi kalau output-nya "Tokyo, ibu kota Jepang" dan expected-nya "Tokyo", Factuality tetep ngasih skor tinggi walau teksnya gak sama persis. Ini jauh lebih cocok buat menilai output LLM.

Penggunaan Lanjutan

Setelah paham dasarnya, sekarang kita masuk ke fitur-fitur yang lebih canggih. Di bagian ini aku bakal bahas custom scorer, bikin scorer sendiri pakai LLM, ngebandingin versi, sampai logging produksi.

Bikin Custom Scorer Sendiri

Scorer bawaan autoevals emang banyak, tapi kadang kalian butuh logika penilaian khusus sesuai kasus kalian. Untungnya bikin scorer sendiri gampang banget. Scorer itu cuma fungsi yang nerima output dan expected, terus ngembaliin skor.

def panjangwajar(output, expected):
    # scorer yang ngasih nilai tinggi kalau panjang output
    # mirip sama panjang expected.
    if not output:
        return 0
    rasio = min(len(output), len(expected)) / max(len(output), len(expected))
    return rasio

Eval(
    "aplikasi-panjang",
    data=lambda: [
        {"input": "Jelaskan singkat apa itu AI", "expected": "AI adalah kecerdasan buatan pada mesin"},
    ],
    task=lambda input: "AI adalah kecerdasan buatan yang ditanamkan ke dalam mesin komputer",
    scores=[panjangwajar],

)

Scorer kayak gini berguna banget buat ngecek hal-hal spesifik, misalnya apakah output kepanjangan, apakah ngandung kata terlarang, apakah formatnya JSON valid, dan seterusnya. Kalian bisa gabungin beberapa scorer sekaligus di list scores, jadi tiap output dinilai dari beberapa sudut pandang.

Scorer juga bisa ngembaliin objek yang lebih detail, bukan cuma angka. Kalian bisa kasih nama dan metadata biar hasilnya lebih informatif di dashboard.

from autoevals import Score

def cekformatjson(output, expected):

    import json
    try:
        json.loads(output)
        return Score(name="formatjson", score=1, metadata={"valid": True})
    except Exception as e:
        return Score(name="formatjson", score=0, metadata={"error": str(e)})

LLM-as-a-Judge Custom

Kadang kriteria penilaian kalian terlalu subjektif buat scorer deterministik. Misalnya kalian pengen nilai apakah sebuah jawaban itu "ramah" atau "profesional". Nah di sini kita bisa pakai LLM buat jadi juri. Autoevals nyediain LLMClassifier buat bikin scorer berbasis LLM dengan gampang.

from autoevals import LLMClassifier

kesopanan = LLMClassifier(
    name="Kesopanan",
    prompttemplate=(
        "Nilai apakah jawaban berikut sopan dan ramah.\n"
        "Pertanyaan: {{input}}\n"
        "Jawaban: {{output}}\n"
        "Apakah jawaban ini sopan? Pilih (a) Sangat sopan, "
        "(b) Cukup sopan, (c) Kurang sopan."
    ),
    choicescores={"a": 1.0, "b": 0.5, "c": 0.0},

    usecot=True,
)

Perhatiin argumen usecot=True. Ini bikin LLM juri mikir dulu (chain of thought) sebelum ngasih keputusan, jadi penilaiannya lebih dapat diandalkan. Field choicescores itu mapping dari pilihan LLM ke skor angka. Jadi kalau LLM milih "a", skornya 1.0, dan seterusnya. Scorer ini bisa langsung kalian masukin ke scores di Eval() kayak scorer lain.

Ngebandingin Versi

Ini menurutku fitur paling powerful dari Braintrust. Tiap kali kalian jalanin Eval(), hasilnya kesimpen jadi experiment baru dengan timestamp. Braintrust otomatis ngebandingin experiment baru sama experiment sebelumnya di project yang sama. Jadi kalian langsung bisa liat apakah skornya naik, turun, atau tetep.

Misalnya kalian punya dua versi prompt yang mau dibandingin. Kalian bisa pakai metadata buat nandain versi mana yang lagi jalan.

from braintrust import Eval, wrapopenai
from autoevals import Factuality
from openai import OpenAI

client = wrapopenai(OpenAI())

PROMPTV1 = "Jawab pertanyaan."

PROMPTV2 = "Jawab pertanyaan dengan singkat, akurat, dan hanya berisi fakta."

def bikintask(systemprompt):
    def task(input):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": systemprompt},

                {"role": "user", "content": input},
            ],
        )
        return response.choices[0].message.content
    return task

DATASET = [
    {"input": "Apa ibu kota Australia?", "expected": "Canberra"},
    {"input": "Siapa presiden pertama Indonesia?", "expected": "Soekarno"},
]

Eval(
    "banding-prompt",
    data=lambda: DATASET,
    task=bikintask(PROMPTV2),

    scores=[Factuality],
    metadata={"versiprompt": "v2"},
)

Kalian jalanin sekali dengan PROMPTV1 dan metadata v1, terus sekali lagi dengan PROMPTV2 dan metadata v2. Di dashboard, Braintrust bakal nampilin dua experiment berdampingan lengkap sama diff skornya. Kalian bisa liat contoh mana yang membaik dan mana yang memburuk. Ini yang bikin kalian bisa ambil keputusan berdasarkan data, bukan feeling.

Yang keren lagi, Braintrust nunjukin regresi per contoh. Jadi kalau skor rata-rata naik tapi ternyata ada beberapa kasus yang malah jadi jelek, kalian bisa langsung liat kasus mana itu dan mutusin apakah trade-off-nya worth it.

Pakai Dataset yang Tersimpan di Braintrust

Sejauh ini dataset kita hardcode di kode. Buat project serius, mendingan dataset disimpen di Braintrust biar bisa dipakai ulang dan dikelola tim. Braintrust nyediain fungsi buat bikin dan ngakses dataset.

from braintrust import initdataset

dataset = initdataset(project="banding-prompt", name="soal-geografi")

nambahin contoh ke dataset
dataset.insert(input="Apa ibu kota Prancis?", expected="Paris")
dataset.insert(input="Apa gunung tertinggi di dunia?", expected="Everest")

pakai dataset di eval
from braintrust import Eval
from autoevals import Factuality

Eval(
    "banding-prompt",
    data=initdataset(project="banding-prompt", name="soal-geografi"),

    task=bikintask(PROMPTV2),

    scores=[Factuality],
)

Dengan cara ini, dataset kalian jadi aset yang bisa terus ditambah. Tiap ada kasus baru dari produksi yang menarik, kalian tinggal masukin ke dataset. Lama-lama dataset kalian jadi makin lengkap dan evaluasinya makin akurat.

Logging Trace Produksi

Nah sekarang kita masuk ke sisi produksi. Selain buat evaluasi sebelum rilis, Braintrust juga bisa ngelacak aplikasi kalian yang udah jalan di produksi. Ini penting banget buat mantau kualitas real-time dan ngumpulin data buat evaluasi selanjutnya.

Cara paling gampang buat mulai logging adalah pakai initlogger terus manfaatin wrapopenai.

from braintrust import initlogger, wrapopenai
from openai import OpenAI

logger = initlogger(project="aplikasi-produksi")
client = wrapopenai(OpenAI())


def handlerequest(pertanyaanuser):

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": pertanyaanuser}],
    )
    return response.choices[0].message.content

tiap panggilan ini otomatis ke-log ke Braintrust
jawaban = handlerequest("Apa itu machine learning?")

print(jawaban)

Karena client-nya dibungkus wrapopenai, tiap panggilan otomatis kecatat lengkap sama input, output, token, dan latency. Kalian gak perlu nambah kode logging manual. Di dashboard kalian bisa liat semua trace produksi, filter berdasarkan waktu, dan analisis pola.

Buat trace yang lebih kompleks, misalnya pipeline RAG yang punya beberapa langkah, kalian bisa pakai decorator @traced buat nandain fungsi mana aja yang mau dilacak.

from braintrust import traced, initlogger, wrapopenai
from openai import OpenAI

logger = initlogger(project="aplikasi-rag")

client = wrapopenai(OpenAI())

@traced
def retrieve(query):
    # bayangin ini nyari dokumen dari vector database
    return ["Dokumen tentang " + query]

@traced
def generate(query, konteks):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Jawab berdasarkan konteks: " + str(konteks)},
            {"role": "user", "content": query},
        ],
    )
    return response.choices[0].message.content

@traced
def ragpipeline(query):

    konteks = retrieve(query)
    return generate(query, konteks)

hasil = ragpipeline("Apa itu transfer learning?")
print(hasil)

Dengan decorator @traced, Braintrust bikin trace berjenjang. Jadi kalian bisa liat pipeline ragpipeline manggil retrieve terus generate, lengkap sama input output tiap langkah. Ini berguna banget buat debugging kalau ada output yang aneh, karena kalian bisa telusuri di langkah mana masalahnya muncul.

Yang bikin siklusnya lengkap, log produksi ini bisa kalian jadiin dataset buat evaluasi. Jadi kalau ada kasus produksi yang menarik atau bermasalah, kalian tinggal tambahin ke dataset evaluasi. Ini bikin evaluasi kalian makin relevan sama kondisi nyata.

Prompt Playground

Fitur terakhir yang mau aku bahas adalah prompt playground. Ini fitur di dashboard Braintrust yang ngasih kalian tempat buat ngoprek prompt secara interaktif tanpa nulis kode. Di playground, kalian bisa nulis prompt, pilih model, atur parameter kayak temperature, terus jalanin ke dataset kalian dan liat hasilnya langsung.

Yang keren, playground ini nyambung sama dataset dan scorer yang udah kalian bikin. Jadi kalian bisa nyoba prompt baru ke dataset yang sama, liat skornya, dan bandingin sama prompt lama, semua di satu tempat tanpa perlu deploy apa-apa. Ini bikin iterasi prompt jadi jauh lebih cepet.

Kalau kalian udah nemu prompt yang bagus di playground, kalian bisa simpan prompt itu sebagai aset di Braintrust dan panggil dari kode. Braintrust nyediain fungsi buat ngambil prompt yang udah disimpen.

from braintrust import loadprompt

prompt = loadprompt(project="aplikasi-qa-llm", slug="jawab-akurat")


build parameter buat dipanggil ke LLM
params = prompt.build(input="Apa ibu kota Kanada?")

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(**params)
print(response.choices[0].message.content)

Dengan cara ini, prompt kalian jadi terpusat di Braintrust. Tim kalian bisa ngoprek prompt di playground, dan kode produksi tinggal manggil prompt versi terbaru tanpa perlu ubah kode. Ini misahin logika prompt dari logika aplikasi, yang mana bagus banget buat maintainability.

Best Practices

Setelah aku pakai Braintrust di beberapa project, ada beberapa hal yang menurutku penting banget buat kalian perhatiin biar hasilnya maksimal.

Yang pertama, mulai dari dataset yang kecil tapi berkualitas. Gak usah langsung bikin ribuan contoh. Mendingan mulai dari sepuluh sampai dua puluh contoh yang bener-bener representatif sama kasus penting kalian. Dataset yang kecil tapi bagus lebih berguna daripada dataset besar yang asal-asalan. Kalian bisa terus nambahin contoh seiring waktu, terutama dari kasus produksi yang bermasalah.

Yang kedua, pilih scorer yang sesuai sama kasus kalian. Jangan asal pakai Levenshtein buat semuanya. Kalau kalian nilai output yang jawabannya bisa beda kata tapi sama makna, pakai Factuality atau LLM-as-a-judge. Kalau kalian ngecek format kayak JSON, pakai scorer deterministik. Gabungin beberapa scorer biar output dinilai dari berbagai sisi. Tapi hati-hati, terlalu banyak scorer juga bikin susah interpretasi. Fokus ke metrik yang beneran penting.

Yang ketiga, selalu jalanin eval sebelum deploy perubahan. Jadikan braintrust eval bagian dari alur kerja kalian, bahkan bisa dimasukin ke CI/CD. Jadi tiap ada perubahan prompt atau model, eval jalan otomatis dan kalian langsung tau kalau ada regresi. Ini nyelametin kalian dari deploy perubahan yang keliatannya bagus tapi ternyata bikin rusak di kasus lain.

Yang keempat, hati-hati sama LLM-as-a-judge. Scorer berbasis LLM itu powerful tapi gak sempurna. Dia sendiri bisa salah nilai. Jadi jangan telan mentah-mentah skornya. Sesekali cek manual apakah penilaian si juri itu masuk akal. Pakai usecot=True biar penilaiannya lebih bisa diandalkan, dan bikin prompt penilaian yang jelas dan spesifik.

Yang kelima, manfaatin metadata sebaik-baiknya. Tandai tiap experiment sama versi prompt, model, dan parameter yang dipakai. Ini bikin kalian gampang nelusuri experiment mana pakai konfigurasi apa waktu ngebandingin. Tanpa metadata yang rapi, kalian bakal bingung sendiri pas experiment-nya udah banyak.

Yang keenam, tutup siklusnya dari produksi ke evaluasi. Jangan cuma logging produksi terus dibiarin. Rutin cek log produksi, cari kasus yang menarik atau bermasalah, terus tambahin ke dataset evaluasi. Dengan begini evaluasi kalian terus berkembang mengikuti kondisi nyata, dan aplikasi kalian makin lama makin bagus.

Yang ketujuh, jaga keamanan API key. Jangan pernah hardcode BRAINTRUSTAPIKEY atau key provider lain di kode. Pakai environment variable atau secret manager. Ini basic tapi sering kelupaan, apalagi kalau lagi buru-buru.

Kesimpulan

Oke temen-temen, kita udah bahas Braintrust dari nol sampai ke fitur-fitur lanjutannya. Kita mulai dari kenapa evaluasi itu penting buat aplikasi LLM, terus konsep intinya kayak dataset, task, scorer, experiment, dan logging. Kita juga udah praktik nulis Eval() pertama, bikin task yang manggil LLM beneran, bikin custom scorer termasuk LLM-as-a-judge, ngebandingin versi prompt, logging trace produksi pakai wrap_openai dan decorator @traced, sampai fitur prompt playground.

Menurutku, hal paling penting yang bisa kalian ambil dari Braintrust adalah pergeseran cara berpikir. Dari ngembangin aplikasi LLM modal feeling, ke ngembangin berdasarkan data yang terukur. Begitu kalian punya dataset dan scorer yang bagus, tiap perubahan yang kalian bikin bisa langsung kalian ukur dampaknya. Gak ada lagi nebak-nebak apakah prompt baru itu lebih bagus. Kalian punya angka konkret buat mutusin.

Buat kalian yang serius pengen bikin aplikasi LLM yang berkualitas dan bisa diandalkan di produksi, aku saranin banget buat mulai integrasiin evaluasi dari awal. Gak perlu langsung sempurna, mulai aja dari beberapa contoh dan satu scorer, terus kembangin pelan-pelan. Braintrust ngasih semua alat yang kalian butuhin buat itu.

Semoga tutorial ini bermanfaat buat kalian ya. Selamat ngoprek dan sampai jumpa di tutorial berikutnya.