1. Setup dan Keberhasilan Pertama

Selamat datang di perjalananmu membangun agen(agent) AI dengan Python! Di akhir bab ini, kamu akan berhasil melakukan panggilan pertamamu ke Large Language Model (LLM) dan memahami persis apa yang terjadi di balik layar. Ini adalah fondasi untuk semua yang akan kamu pelajari setelahnya.

Prasyarat

Audiens & Asumsi

Buku ini ditulis untuk developer Python yang ingin membangun agen(agent) AI tetapi belum punya pengalaman sebelumnya dengan LLM atau framework AI. Kami mengasumsikan kamu nyaman dengan:

• Dasar-dasar Python: fungsi, class, import, struktur data dasar
• Python 3.10+: Kamu sebaiknya sudah memasang Python 3.10 atau lebih tinggi di sistemmu
• Virtual environment: membuat dan mengaktifkan venv dengan python -m venv
• Manajemen paket: memasang paket dengan pip
• Environment variable: mengatur dan membaca environment variable di shell-mu
• API key: memahami apa itu API key dan bagaimana mendapatkannya dari penyedia layanan

Jika salah satu konsep ini masih asing, kami menyarankan untuk mempelajarinya terpisah sebelum lanjut. Dokumentasi Python serta tutorial tentang virtual environment dan pip adalah titik awal yang bagus.

Yang TIDAK kami asumsikan: Kamu tidak butuh latar belakang machine learning, neural network, transformer, atau teori AI. Kami akan menjelaskan konsep yang spesifik ke LLM saat kita menemukannya, dan selalu mengaitkannya dengan pola pemrograman yang sudah familiar.

Konvensi Model

Sepanjang buku ini, kita akan menggunakan GPT-5-mini sebagai model default untuk contoh. Alasannya:

• Tersedia luas: API OpenAI bisa diakses secara global dengan pendaftaran yang sederhana
• Kecepatan yang masuk akal: Dengan upaya penalaran minimal, respons datang cukup cepat untuk pengembangan iteratif
• Hemat biaya: Dengan $0.25 per satu juta input token dan $2.00 per satu juta output token (per 2026), harganya terjangkau untuk belajar dan eksperimen
• Kemampuan memadai: Model ini menangani sebagian besar tugas agen(agent) AI yang praktis dengan baik

Saat kamu melihat contoh kode tanpa model yang disebutkan secara eksplisit, anggap saja kita menggunakan GPT-5-mini. Di Bab 2, kita akan mengeksplorasi lanskap lengkap model yang tersedia (Claude, Gemini, dan varian GPT lainnya) dan membahas kapan kamu mungkin memilih alternatif berdasarkan ukuran context window, biaya, atau kemampuan khusus.

1.1) Apa itu LLM?

Sebelum kita menulis kode apa pun, mari tetapkan dulu apa yang sebenarnya sedang kita gunakan. Large Language Model (LLM) adalah neural network yang dilatih pada jumlah data teks yang sangat besar untuk memprediksi teks apa yang seharusnya muncul berikutnya dalam sebuah urutan.

Bayangkan seperti sistem autocomplete yang sangat canggih. Saat kamu mengetik di ponsel dan ia menyarankan kata berikutnya, itu versi sederhana dari apa yang dilakukan LLM. Tetapi LLM beroperasi pada skala dan kecanggihan yang memungkinkan mereka untuk:

• Menghasilkan jawaban yang koheren dan sesuai konteks terhadap pertanyaan
• Menulis kode, esai, email, dan konten terstruktur lainnya
• Menerjemahkan antarbahasa
• Merangkum dokumen panjang
• Mengekstrak informasi dari teks yang tidak terstruktur
• Dan masih banyak lagi

Perbedaan LLM dengan Software Tradisional

Software tradisional mengikuti aturan eksplisit yang kamu program:

def calculate_discount(price, customer_type):
    if customer_type == "premium":
        return price * 0.8  # diskon 20%
    elif customer_type == "regular":
        return price * 0.95  # diskon 5%
    else:
        return price

Fungsi ini selalu menghasilkan output yang sama untuk input yang sama. Logikanya deterministik dan transparan.

LLM bekerja berbeda. Alih-alih aturan eksplisit, mereka menggunakan pola yang dipelajari dari data pelatihan untuk menghasilkan respons. Kamu memberi teks input (disebut prompt), dan model menghasilkan teks output (disebut completion atau response).

# Contoh konseptual - sebentar lagi kita akan menulis kode yang nyata
response = llm.generate("Berapa diskon yang bagus untuk pelanggan premium?")
# Contoh output: "Pelanggan premium biasanya mendapat diskon 15-25%..."

LLM tidak punya persentase diskon yang di-hardcode. Ia menghasilkan respons berdasarkan pola yang dipelajari saat pelatihan. Ini berarti:

1. Respons bisa bervariasi: prompt yang sama bisa menghasilkan respons yang sedikit berbeda setiap kali
2. Perilaku dipelajari, bukan diprogram: kamu membimbing model dengan prompt alih-alih menulis logika eksplisit
3. Kemampuan muncul dari skala: model bisa menangani tugas yang tidak dilatih secara eksplisit

Terminologi Kunci

Mari definisikan istilah yang akan kamu temui terus-menerus:

• Prompt: Teks input yang kamu kirim ke model. Anggap saja sebagai "pertanyaan" atau "instruksi"
• Completion/Response: Teks yang dihasilkan model sebagai respons atas prompt-mu
• Token: Unit dasar yang digunakan LLM. Kira-kira, 1 token ≈ 4 karakter atau ¾ dari sebuah kata. "Hello world" sekitar 2 token
• Context window: Jumlah maksimum teks (dalam token) yang bisa diproses model sekaligus. GPT-5-mini punya context window 400K token
• Temperature: Parameter yang mengontrol keacakan. Lebih rendah (0.0-0.3) = lebih fokus dan deterministik. Lebih tinggi (0.7-1.0) = lebih kreatif dan bervariasi

Apa yang Bisa dan Tidak Bisa Dilakukan LLM

Memahami apa yang LLM lakukan dengan andal—dan apa yang hanya tampak mereka lakukan—itu penting untuk membangun agen(agent) AI yang robust.

LLM sangat bagus untuk:

• Memahami dan menghasilkan bahasa alami: Mereka bisa mem-parsing intent, menghasilkan respons koheren, dan menangani frasa yang kompleks

"Saya ingin refund" → Mengenali intent: refund_request
"Ringkas dokumen ini" → Menghasilkan ringkasan yang singkat

• Mengikuti instruksi dalam prompt: Saat diberi arahan yang jelas, mereka bisa menghasilkan output terstruktur seperti JSON atau teks berformat

"Ubah ke JSON: John Smith, 32, tinggal di Boston"
→ {"name": "John Smith", "age": 32, "city": "Boston"}

• Mengenali pola dalam teks: Analisis sentimen, kategorisasi, dan ekstraksi informasi bekerja dengan andal

• Menghasilkan kode dan konten terstruktur: Bisa menulis Python, SQL, atau output berformat lain yang valid saat diprompt dengan benar

• Penalaran langkah demi langkah: Saat secara eksplisit diminta untuk "think step-by-step", mereka memecah masalah secara metodis

Keterbatasan LLM:

• Bukan database: Mereka tidak mengambil fakta—mereka menghasilkan teks yang secara statistik terlihat masuk akal. Mereka bisa menyatakan informasi yang salah dengan percaya diri, dan terdengar otoritatif.

"Kapan Python 4.0 dirilis?" 
→ Bisa menghasilkan "Python 4.0 dirilis pada 2023" (salah, tapi masuk akal)

• Bukan kalkulator: Mereka memprediksi seperti apa seharusnya jawaban, bukan menghitungnya. Aritmetika sederhana sering berhasil; matematika kompleks gagal secara tidak terduga.

"Berapa 8,247 × 6,839?" → Bisa menghasilkan hasil yang salah namun terlihat masuk akal

• Tidak deterministik: prompt yang sama bisa menghasilkan output berbeda setiap kali. Variabilitas ini dikontrol oleh parameter temperature.

• Tidak selalu akurat: Mereka menghasilkan teks yang terdengar masuk akal terlepas dari kebenaran faktanya. "Halusinasi"—informasi yang detail, percaya diri, namun sepenuhnya dibuat-buat—sering terjadi.

Insight kunci: Bangun agen(agent) yang menggabungkan LLM (untuk pemahaman dan pengambilan keputusan) dengan tool tradisional (untuk perhitungan, pengambilan data, dan operasi faktual). Kita akan mengimplementasikan pola ini mulai Bab 13, ketika LLM memutuskan kapan harus memakai kalkulator daripada mencoba matematika sendiri.

Apa yang Akan Kamu Pelajari

Di buku ini, kamu akan belajar membangun agen(agent) AI - sistem di mana LLM secara otonom memutuskan tindakan apa yang harus diambil untuk mencapai tujuan, alih-alih mengikuti logika yang sudah ditentukan. Kita akan mengeksplorasi paradigma ini secara mendalam di Bab 2.

1.2) Instal Dependensi

Mari siapkan environment pengembanganmu. Kita akan membuat struktur proyek yang bersih dan memasang LangChain, framework yang akan kita gunakan untuk membangun agen(agent) AI.

Verifikasi Instalasi Python

Pertama, pastikan Python sudah terpasang di sistemmu. Kami merekomendasikan Python 3.10 atau lebih tinggi (per 2026, Python 3.13 atau 3.14 adalah pilihan yang bagus).

Cek versi Python-mu:

python --version
# or
python3 --version

Kamu seharusnya melihat output seperti Python 3.13.x atau Python 3.14.x.

Jika Python belum terpasang:

• macOS:

  • Unduh dari python.org
  • Atau gunakan Homebrew: brew install python@3.14

• Windows:

  • Unduh dari python.org
  • Centang "Add Python to PATH" saat instalasi

• Linux:

  • Ubuntu/Debian: sudo apt update && sudo apt install python3.14
  • Fedora: sudo dnf install python3.14

Setelah instalasi, verifikasi lagi dengan python --version.

Catatan: Di beberapa sistem, kamu mungkin perlu memakai python3 alih-alih python. Sepanjang buku ini, jika python tidak bekerja, coba python3.

Buat Proyekmu

Buka terminal dan buat direktori baru untuk proyekmu:

mkdir agentic-ai-project
cd agentic-ai-project

Buat virtual environment untuk mengisolasi dependensi:

python -m venv venv

Aktifkan virtual environment:

# On macOS/Linux:
source venv/bin/activate
 
# On Windows:
venv\Scripts\activate

Kamu seharusnya melihat (venv) muncul di prompt terminalmu, menandakan virtual environment aktif.

Instal LangChain dan OpenAI

Kita akan memasang integrasi OpenAI untuk LangChain, yang mencakup semua yang dibutuhkan untuk bekerja dengan model OpenAI:

pip install langchain-openai

Ini memasang langchain-openai beserta dependensinya, termasuk langchain-core (abstraksi inti LangChain) dan klien Python OpenAI. Kamu seharusnya melihat output yang mengonfirmasi instalasi beberapa paket.

Verifikasi instalasi:

pip show langchain-openai

Kamu seharusnya melihat detail tentang paket yang terpasang, termasuk nomor versi dan lokasinya. Ini mengonfirmasi instalasi berhasil.

Dapatkan OpenAI API Key-mu

Untuk memanggil model OpenAI, kamu butuh API key:

1. Buka platform.openai.com
2. Daftar atau masuk
3. Buka API Keys di pengaturan akunmu
4. Klik "Create new secret key"
5. Salin key (diawali dengan sk-)

⚠️ Peringatan Keamanan: Perlakukan key ini seperti password. Jangan pernah commit ke version control atau membagikannya secara publik. Siapa pun yang punya key-mu bisa melakukan API call yang akan ditagihkan ke akunmu.

Set API Key-mu sebagai Environment Variable

Cara yang direkomendasikan untuk menyediakan API key adalah lewat environment variable:

# On macOS/Linux:
export OPENAI_API_KEY='sk-your-actual-key-here'
 
# On Windows (Command Prompt):
set OPENAI_API_KEY=sk-your-actual-key-here
 
# On Windows (PowerShell):
$env:OPENAI_API_KEY='sk-your-actual-key-here'

Catatan: Pengaturan ini bersifat sementara dan akan hilang saat kamu menutup terminal. Untuk solusi permanen, kamu bisa:

• Menambahkan perintah export ke file konfigurasi shell-mu (.bashrc, .zshrc, dll.)
• Menggunakan file .env (kita akan menyiapkannya di Bab 3 untuk organisasi proyek yang lebih baik)

Untuk sekarang, pengaturan sementara sudah cukup untuk lanjut.

Verifikasi bahwa sudah terset:

# On macOS/Linux:
echo $OPENAI_API_KEY
 
# On Windows (Command Prompt):
echo %OPENAI_API_KEY%
 
# On Windows (PowerShell):
echo $env:OPENAI_API_KEY

Kamu seharusnya melihat API key-mu tercetak. Jika tidak, ulangi perintah export/set dan pastikan tidak ada typo.

1.3) Panggilan LLM Pertamamu

Sekarang bagian yang seru - mari lakukan panggilan pertamamu ke LLM. Buat file bernama first_call.py:

# first_call.py
from langchain_openai import ChatOpenAI
 
# Inisialisasi LLM
llm = ChatOpenAI(model="gpt-5-mini")
 
# Kirim prompt dan dapatkan respons
response = llm.invoke("What is LangChain?")
 
# Cetak respons
print(response.content)

Jalankan:

python first_call.py

Kamu seharusnya melihat output mirip seperti ini (kata-katanya bisa berbeda):

LangChain is a framework designed to simplify the development of applications powered by large language models (LLMs). It provides tools and abstractions for building chains of LLM calls, integrating external data sources, managing prompts, and creating agents that can interact with various APIs and databases. LangChain makes it easier to build complex AI applications by providing reusable components and patterns.

Selamat! Kamu baru saja melakukan panggilan LLM pertamamu. Mari bedah apa yang terjadi di kode ini.

Troubleshooting: Jika kamu melihat error:

• AuthenticationError: API key tidak valid atau belum diset → Cek environment variable OPENAI_API_KEY (lihat bagian 1.2)
• RateLimitError: Request terlalu cepat atau limit penggunaan terlampaui → Tunggu beberapa detik lalu coba lagi, atau cek penggunaan di platform.openai.com/usage
• APIConnectionError: Masalah konektivitas jaringan → Cek koneksi internetmu

Memahami Kodenya

Import wrapper LLM:

from langchain_openai import ChatOpenAI

ChatOpenAI adalah wrapper LangChain untuk model chat OpenAI. Ia menangani autentikasi API, formatting request, dan parsing respons untukmu.

Inisialisasi model:

llm = ChatOpenAI(model="gpt-5-mini")

Ini membuat instance yang dikonfigurasi untuk memakai GPT-5-mini. Di balik layar, LangChain membaca environment variable OPENAI_API_KEY untuk autentikasi. Kamu juga bisa mengirimkan key secara eksplisit:

llm = ChatOpenAI(model="gpt-5-mini", api_key="sk-your-key")

Tapi menggunakan environment variable lebih aman dan fleksibel.

Invoke model:

response = llm.invoke("What is LangChain?")

Metode invoke() mengirim prompt-mu ke API OpenAI dan menunggu respons lengkap. Ini adalah pemanggilan sinkron - programmu berhenti sementara sampai respons datang.

Akses isi respons:

print(response.content)

Objek respons berisi beberapa field. Field .content menyimpan teks aktual yang dihasilkan model. Kita akan mengeksplorasi field lain di bagian berikutnya.

Coba Prompt yang Berbeda

Ubah prompt untuk melihat bagaimana model merespons input yang berbeda:

# first_call.py
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
 
# Coba prompt yang berbeda
prompts = [
    "Explain Python decorators in one sentence.",
    "What's 15 * 23?",
    "List three benefits of using type hints in Python.",
]
 
for prompt in prompts:
    response = llm.invoke(prompt)
    print(f"Prompt: {prompt}")
    print(f"Response: {response.content}\n")

Model menangani berbagai jenis request - penjelasan, perhitungan, dan daftar terstruktur. Kamu akan melihat bahwa respons bisa sedikit bervariasi kalau kamu menjalankan prompt yang sama berkali-kali. Ini perilaku normal - kita akan mengeksplorasi kenapa ini terjadi dan bagaimana mengontrolnya di Bab 2.

1.4) Apa yang Baru Saja Terjadi? (Alur Request → Model → Response)

Mari kita periksa persis apa yang terjadi saat kamu memanggil llm.invoke(). Memahami alur ini penting untuk membangun agen(agent) AI yang andal.

Siklus Request-Response Lengkap

Mari telusuri setiap langkah:

Langkah 1: Kodemu Memanggil invoke()

response = llm.invoke("What is LangChain?")

Metode invoke() adalah interface utamamu ke LLM. Kamu memasukkan string prompt, dan ia mengembalikan objek respons yang berisi jawaban model. Di balik pemanggilan sederhana ini, beberapa langkah terjadi secara otomatis.

Langkah 2: LangChain Memformat Request

LangChain mentransformasi string-mu menjadi request API yang terstruktur. Di balik layar, ia membuat payload JSON seperti ini:

{
  "model": "gpt-5-mini",
  "messages": [
    {
      "role": "user",
      "content": "What is LangChain?"
    }
  ],
  "temperature": 1.0
}

Array messages adalah cara model chat menerima input. Setiap message punya role (user, assistant, atau system) dan content (teksnya). Kita akan mengeksplorasi peran message di Bab 4.

Langkah 3: API Call ke OpenAI

LangChain mengirim request HTTPS POST ke endpoint API OpenAI:

POST https://api.openai.com/v1/chat/completions
Authorization: Bearer sk-your-api-key
Content-Type: application/json
 
{request payload}

API key-mu mengautentikasi request. Server OpenAI menerima request dan merutekannya ke model yang ditentukan.

Langkah 4: Model Memproses Prompt

GPT-5-mini menerima prompt-mu dan menghasilkan respons token demi token. Model:

1. Mengonversi teksmu menjadi token (representasi numerik)
2. Memproses token melalui layer-layer neural network-nya
3. Memprediksi token berikutnya yang paling mungkin
4. Mengulang sampai menghasilkan respons lengkap atau mencapai kondisi berhenti

Ini terjadi di server OpenAI - kodemu hanya menunggu hasilnya.

Langkah 5: API Mengembalikan Respons

API OpenAI mengirim kembali respons JSON:

{
  "id": "chatcmpl-8x7y9z",
  "object": "chat.completion",
  "created": 1704067200,
  "model": "gpt-5-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "LangChain is a framework designed to simplify..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 58,
    "total_tokens": 70
  }
}

Field penting:

• message.content: Teks yang dihasilkan
• usage: Jumlah token untuk penagihan dan monitoring
• finish_reason: Alasan generasi berhenti ("stop" = selesai secara natural, "length" = mencapai limit token)

Langkah 6: LangChain Mem-parse Respons

LangChain mengonversi JSON menjadi objek Python yang bisa kamu gunakan:

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
response = llm.invoke("What is LangChain?")
 
# Eksplor objek respons
print(f"Content: {response.content}")
print(f"Type: {type(response)}")
print(f"Response metadata: {response.response_metadata}")

Output:

Content: LangChain is a framework designed to simplify...
Type: <class 'langchain_core.messages.ai.AIMessage'>
Response metadata: {'token_usage': {'completion_tokens': 58, 'prompt_tokens': 12, 'total_tokens': 70}, 'model_name': 'gpt-5-mini', 'finish_reason': 'stop'}

Respons adalah objek AIMessage dengan beberapa atribut yang berguna:

• content: Teks yang dihasilkan (yang biasanya kamu butuhkan)
• response_metadata: Penggunaan token, nama model, alasan selesai
• id: Identifier unik untuk respons ini
• usage_metadata: Rincian token yang lebih detail

Memahami Penggunaan Token

Sebelum melihat jumlah token, catatan singkat: token adalah unit dasar yang diproses LLM. Dalam bahasa Inggris, teks biasanya memakai sedikit lebih dari 1 token per kata (mis., "explain quantum computing" = 3 kata, 4-5 token), tetapi bahasa non-Inggris seperti Korea atau Mandarin membutuhkan jauh lebih banyak token untuk merepresentasikan teks yang sama. Kita akan mengeksplorasi token lebih detail di Bab 2.

Mari kita lihat konsumsi token lebih dekat:

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
response = llm.invoke("Explain quantum computing in simple terms.")
 
usage = response.response_metadata['token_usage']
print(f"Input tokens: {usage['prompt_tokens']}")
print(f"Output tokens: {usage['completion_tokens']}")
print(f"Total tokens: {usage['total_tokens']}")

Output:

Input tokens: 11
Output tokens: 95
Total tokens: 106

Catatan: prompt_tokens = input tokens (prompt-mu), completion_tokens = output tokens (respons model), total_tokens = jumlah keduanya.

Konsumsi token bervariasi berdasarkan:

• Panjang prompt: Prompt yang lebih panjang memakai lebih banyak input token
• Detail respons: Respons yang detail menghasilkan lebih banyak output token
• Kompleksitas bahasa: Istilah teknis dan kode bisa ditokenisasi berbeda

Misalnya, prompt pendek seperti "What's 2+2?" mungkin hanya memakai 5-6 input token dan 8-10 output token, sementara "Write a detailed essay about the history of Python programming language" bisa memakai 15-20 input token dan 500+ output token.

Perhitungan biaya untuk contoh di atas:

Dengan harga GPT-5-mini ($0.25 per satu juta input token, $2.00 per satu juta output token):

• Input: 11 token × $0.25 / 1,000,000 = $0.00000275
• Output: 95 token × $2.00 / 1,000,000 = $0.00019
• Total: ~$0.0002 (dua per seratus sen)

Kamu membayar untuk input dan output token, tetapi output token lebih mahal (8× dalam kasus ini).

Apa yang Sudah Kamu Pelajari

Sekarang kamu memahami lifecycle lengkap dari sebuah panggilan LLM:

1. Kodemu menyediakan string prompt
2. LangChain memformatnya menjadi request API dengan autentikasi
3. OpenAI API merutekan request ke model
4. Model menghasilkan respons token demi token
5. API mengembalikan JSON terstruktur dengan respons dan metadata
6. LangChain mem-parse-nya menjadi objek Python
7. Kodemu mengakses konten dan metadata

Kamu juga sudah belajar:

• Cara menginspeksi objek respons dan mengekstrak metadata
• Cara penggunaan token memengaruhi biaya

Fondasi ini menyiapkanmu untuk Bab 2, di mana kita akan mengeksplorasi bagaimana LLM benar-benar bekerja di balik layar, membandingkan berbagai model, dan mempelajari teknik prompt engineering untuk mendapatkan hasil yang lebih baik.