Pendahuluan
Halo, rekan developer! Senang sekali bisa bertemu kembali di seri tutorial LLM ini. Pada artikel sebelumnya, kita sudah membedah mekanisme internal LLM melalui konsep tokenisasi. Kita belajar bahwa teks tidak dibaca sebagai kata utuh, melainkan sebagai potongan-potongan kecil bernama token, dan bagaimana jumlah token ini sangat menentukan biaya yang harus kita keluarkan.
Sekarang, saatnya kita beralih dari teori ke implementasi nyata. Jika sebelumnya kita hanya memahami “apa itu LLM”, sekarang kita akan belajar “bagaimana cara menggunakannya”. Kita akan belajar cara melakukan request atau pemanggilan ke server LLM menggunakan bahasa pemrograman Python.
Dalam tutorial ini, kita akan membangun inti dari proyek Chatbot Sederhana kita. Kita akan belajar cara mengamankan API Key agar tidak bocor ke publik, cara menyusun pesan agar dipahami oleh model, hingga cara mengambil jawaban dari API dan menampilkannya di terminal. Setelah menyelesaikan artikel ini, Anda akan memiliki fondasi yang kuat untuk membangun aplikasi berbasis AI yang lebih kompleks seperti asisten virtual atau bot otomatis.
Mengelola API Key dengan Aman (Environment Variables)
Saat bekerja dengan API (seperti OpenAI, Anthropic, atau Google Gemini), hal paling krusla adalah menjaga kerahasiaan API Key. Bayangkan jika Anda sedang membangun aplikasi untuk toko online seperti Tokopedia, lalu tanpa sengaja Anda mengunggah kode yang berisi API Key ke GitHub publik. Orang lain bisa menggunakan kuota API Anda, dan jika Anda menggunakan sistem pembayaran kartu kredit, tagihan Anda bisa membengkak hingga jutaan Rupiah dalam sekejap!
Oleh karena itu, kita tidak boleh menuliskan API Key langsung di dalam kode program (hardcoded). Standar industri yang digunakan oleh para senior developer adalah menggunakan Environment Variables melalui file .env.
Mari kita siapkan lingkungannya. Pertama, instal library python-dotenv yang berfungsi untuk membaca file .mock.
pip install python-dotenv openaiSetelah itu, buatlah sebuah file bernama .env di folder proyek Anda. Isi file tersebut dengan API Key Anda:
# File: .env
# Jangan pernah membagikan file ini ke publik!
OPENAI_API_KEY=sk-proj-your-secret-key-hereKemudian, buatlah file .gitignore agar file .env tidak ikut terunggah ke GitHub. Cukup tuliskan satu baris:
# File: .gitignore
.envSekarang, mari kita lihat bagaimana cara mengambil nilai tersebut di dalam Python:
import os
from dotenv import load_dotenv
# Memuat variabel dari file .env ke dalam environment sistem
load_dotenv()
# Mengambil API Key dari environment variable
api_key = os.getenv("OPENBB_API_KEY")
if api_key:
print("✅ API Key berhasil dimuat!")
else:
print("❌ API Key tidak ditemukan. Periksa file .env Anda.")Memahami Struktur Request dan Response API
Memanggil API LLM sebenarnya adalah melakukan pengiriman data melalui protokol HTTP (biasanya menggunakan metode POST). Data yang kita kirimkan bukan sekadar teks biasa, melainkan sebuah struktur JSON yang berisi instruksi khusus.
Dalam ekosistem LLM modern, terdapat konsep Roles (Peran) dalam percakapan. Ada tiga peran utama yang harus Anda pahami:
- System Role: Ini adalah instruksi “kepribadian”. Di sini Anda memberi tahu model siapa dia. Contoh: “Kamu adalah asisten yang ahli dalam keuangan perbankan seperti BCA atau Mandiri.”
- berikutnya User Role: Ini adalah pesan atau pertanyaan dari pengguna (seperti Budi atau Siti).
- Assistant Role: Ini adalah respon balik dari model LLM.
Struktur pesan ini biasanya berbentuk sebuah array of objects. Mari kita lihat contoh bagaimana menyusun struktur pesan tersebut menggunakan library openai yang sangat populer:
import os
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv()
# Inisialisasi client dengan API Key yang sudah aman
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def prepare_messages():
# Menyusun struktur pesan (Chat Completion)
messages = [
{
"role": "system",
"content": "Kamu adalah asisten cerdas yang membantu pengguna Indonesia dengan gaya bahasa yang sopan."
},
{
"role": "user",
"content": "Halo, siapa namamu?"
}
]
return messages
# Contoh cara mengirimkan pesan tersebut ke API
def call_llm_api(messages):
try:
response = client.chat.completions.create(
model="gpt-3.5-turbo", # Anda bisa mengganti dengan model lain
messages=messages,
temperature=0.7 # Mengatur kreativitas (0 = kaku, 1 = sangat kreatif)
)
# Mengambil isi jawaban dari struktur JSON yang kompleks
answer = response.choices[0].message.content
return answer
except Exception as e:
return f"Terjadi kesalahan: {str(e)}"
# Eksekusi sederhana
chat_messages = prepare_messages()
print("Sedang memproses jawaban...")
print(f"Jawaban AI: {call_llm_api(chat_messages)}")Perhatikan bagian response.choices[0].message.content. API tidak langsung memberikan teks mentah. Ia memberikan objek JSON besar yang berisi informasi penggunaan token, alasan berhenti (finish reason), dan baru kemudian teks jawabannya berada di dalam array choices.
Implementasi dalam Proyek: Chatbot Sederhana
Sekarang, mari kita satukan semua potongan kode di atas ke dalam proyek utama kita: Chatbot Sederhana. Kita akan membuat sebuah loop (perulangan) di terminal sehingga Anda bisa terus mengobrol dengan AI tanpa harus menjalankan ulang program berkali-kali.
Berikut adalah kode lengkapnya. Simpan kode ini dengan nama chatbot.py.
import os
from dotenv import load_dotenv
from openai import OpenAI
# 1. Persiapan Lingkungan
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def start_chatbot():
# 2. Inisialisasi History Percakapan
# Kita menggunakan role 'system' untuk menentukan kepribadian bot
chat_history = [
{
"role": "system",
"content": "Kamu adalah asisten chatbot bernama 'BudiBot'. Kamu sangat ramah dan selalu menggunakan bahasa Indonesia yang baik."
}
]
print("=== BudiBot: Chatbot Sederhana Indonesia ===")
print("(Ketik 'keluar' untuk mengakhiri percakapan)\n")
# 3. Loop Percakapan Utama
while True:
# Mengambil input dari user (misal: Andi atau Siti)
user_input = input("Anda: ")
# Cek jika user ingin berhenti
if user_input.lower() in ['keluar', 'exit', 'quit']:
print("BudiBot: Sampai jumpa lagi! Terima kasih sudah mengobrol.")
break
# Tambahkan pesan user ke dalam history agar AI punya konteks
chat_history.append({"role": "user", "content": user_input})
try:
# 4. Memanggil API LLM
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=chat_history,
)
# 5. Mengambil jawaban dan menampilkannya
bot_response = response.choices[0].message.content
print(f"BudiBot: {bot_response}\n")
# Simpan jawaban bot ke history agar percakapan tetap nyambung (contextual)
chat_history.append({"role": "assistant", "content": bot_response})
except Exception as e:
print(f"Terjadi kesalahan koneksi: {e}")
break
if __name__ == "__main__":
start_chatbot()Penjelasan Logika Penting:
- Contextual Memory: Perhatikan bagian
chat_history.append(...). Tanpa baris ini, chatbot akan “amnesia”. Ia tidak akan ingat apa yang Anda katakan di pesan sebelumnya. Dengan menyimpan riwayat ke dalam list, setiap kali kita mengirim pesan baru, kita juga mengirimkan seluruh riwayat percakapan sebelumnya. - Error Handling: Kita menggunakan blok
try...exceptuntuk mencegah program crash jika tiba-tiba koneksi internet terputus atau kuota API habis.
Kesimpulan
Anda sekarang telah berhasil membangun chatbot dasar yang memiliki kemampuan mengingat konteks. Anda telah belajar cara mengamankan API Key menggunakan .env, cara menyusun struktur pesan (system, user, assistant), dan cara mengelola riwayat percakapan.
Langkah selanjutnya adalah mempelajari bagaimana cara membatasi jumlah token agar biaya API tidak membengkak, yang akan kita bahas di materi berikutnya tentang Token Management.
Selamat mencoba, dan selamat coding!