Memahami Antarmuka Obrolan
Pelajari cara kerja UI obrolan LLM: peran, giliran, dan konteks sesi.
Memahami Antarmuka Obrolan adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Prompt Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Prompt Engineering mencakup 4 pelajaran total.
Tiga Peran
Setiap percakapan dengan LLM dibangun dari tiga peran: sistem, pengguna, dan asisten.
Peran system menetapkan aturan dan persona sebelum percakapan dimulai. Peran user adalah Anda yang mengirim pesan. Peran assistant adalah model yang membalas.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
message = client.messages.create(
model='claude-opus-4-5',
max_tokens=256,
system='You are a helpful cooking assistant.',
messages=[
{'role': 'user', 'content': 'What is mise en place?'}
]
)
print(message.content[0].text)Pesan Sistem
Pesan sistem adalah buku petunjuk model. Pesan ini dijalankan sebelum giliran pengguna pertama dan tetap aktif sepanjang sesi.
Gunakan pesan ini untuk menetapkan persona, nada, batasan domain, atau format keluaran. Model memperlakukannya sebagai konteks panduan sepanjang percakapan.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
response = client.chat.completions.create(
model='gpt-4o',
messages=[
{
'role': 'system',
'content': 'You are a senior Python engineer. '
'Always include type hints and docstrings in your examples.'
},
{
'role': 'user',
'content': 'Show me a function that parses JSON safely.'
}
]
)
print(response.choices[0].message.content)Giliran dan Alur Percakapan
Suatu percakapan merupakan rangkaian giliran. Setiap giliran berlangsung bergantian: pengguna berbicara, asisten menjawab, lalu pengguna berbicara lagi.
Model melihat seluruh riwayat giliran pada setiap permintaan. Hal inilah yang membuatnya terasa seperti dialog berkelanjutan — tetapi secara teknis, setiap pemanggilan API bersifat tanpa status dan menerima seluruh konteks setiap kali.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Each call sends the FULL conversation history
history = [
{'role': 'system', 'content': 'You are a geography tutor.'},
{'role': 'user', 'content': 'What is the capital of France?'},
{'role': 'assistant', 'content': 'The capital of France is Paris.'},
{'role': 'user', 'content': 'And its population?'} # follow-up turn
]
response = client.chat.completions.create(
model='gpt-4o',
messages=history
)
print(response.choices[0].message.content)Konteks Sesi
Konteks sesi adalah memori percakapan Anda yang terus berjalan. Setiap pesan pengguna dan asisten terakumulasi dalam larik riwayat.
Model tidak memiliki penyimpanan memori terpisah — model sepenuhnya membuat penalaran berdasarkan apa yang dilihatnya dalam jendela konteks saat ini. Jika Anda memulai sesi baru, model tidak memiliki ingatan tentang sesi sebelumnya kecuali Anda memasukkan kembali informasi tersebut.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# Simulating 3-turn session context
conversation = [
{'role': 'user', 'content': 'My name is Alex.'},
{'role': 'assistant', 'content': 'Nice to meet you, Alex!'},
{'role': 'user', 'content': 'What is 5 times 7?'},
{'role': 'assistant', 'content': '5 times 7 is 35.'},
{'role': 'user', 'content': 'Can you repeat my name?'} # uses session context
]
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=128,
messages=conversation
)
print(response.content[0].text) # expects: Your name is Alex.Struktur Riwayat Pesan
Riwayat pesan hanyalah daftar kamus, yang masing-masing memiliki kunci role dan content.
Anda mengelola daftar ini sendiri dalam kode. Setelah setiap balasan asisten, Anda menambahkan responsnya, lalu menambahkan pesan pengguna berikutnya — dan mengirim seluruh daftar itu lagi pada pemanggilan berikutnya.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
def chat(history, user_message):
history.append({'role': 'user', 'content': user_message})
response = client.chat.completions.create(
model='gpt-4o',
messages=history
)
reply = response.choices[0].message.content
history.append({'role': 'assistant', 'content': reply})
return reply, history
history = [{'role': 'system', 'content': 'You are a math tutor.'}]
reply, history = chat(history, 'What is a prime number?')
print(reply)
print('History length:', len(history))Penjelasan Batas Token
Setiap model memiliki jendela konteks yang diukur dalam token. Satu token kira-kira terdiri dari 4 karakter atau 0,75 kata dalam bahasa Inggris.
Baik input Anda (sistem + seluruh riwayat) maupun output model dihitung dalam batas ini. GPT-4o mendukung 128 ribu token; Claude Opus 4.5 mendukung 200 ribu. Saat batas tercapai, pesan yang lebih lama harus dihapus atau diringkas.
import tiktoken
# Count tokens before sending to avoid exceeding the limit
encoding = tiktoken.encoding_for_model('gpt-4o')
messages = [
{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': 'Explain quantum entanglement in simple terms.'}
]
total_tokens = 0
for msg in messages:
total_tokens += len(encoding.encode(msg['content']))
total_tokens += 4 # overhead per message
print(f'Estimated input tokens: {total_tokens}')
print(f'GPT-4o limit: 128,000 tokens')
print(f'Budget remaining: {128000 - total_tokens:,} tokens')Apa yang Terjadi Saat Batas Token Tercapai
Saat riwayat percakapan bertambah melampaui jendela konteks, Anda memiliki tiga pilihan:
- Potong — hapus pesan yang paling lama
- Ringkas — minta model memadatkan giliran percakapan sebelumnya menjadi ringkasan singkat
- Jendela geser — pertahankan hanya N pesan terakhir
Memilih strategi yang salah dapat menyebabkan model kehilangan konteks penting dan memberikan jawaban yang tidak koheren.
def trim_history(history, max_messages=10, keep_system=True):
'''Keep the system message and the last N non-system messages.'''
system_msgs = [m for m in history if m['role'] == 'system']
non_system = [m for m in history if m['role'] != 'system']
if len(non_system) > max_messages:
non_system = non_system[-max_messages:]
print(f'Trimmed to last {max_messages} messages.')
return system_msgs + non_system if keep_system else non_system
history = [{'role': 'system', 'content': 'You are a tutor.'}]
for i in range(15):
history.append({'role': 'user', 'content': f'Question {i}'})
history.append({'role': 'assistant', 'content': f'Answer {i}'})
trimmed = trim_history(history, max_messages=6)
print('Trimmed history length:', len(trimmed))Konteks Percakapan Multi-giliran dalam Praktik
Mari kita lihat konteks dalam praktik. Dalam percakapan multi-giliran, model menggunakan setiap pesan sebelumnya untuk menjawab pertanyaan lanjutan dengan benar.
Itulah sebabnya Anda dapat mengatakan 'jelaskan itu dengan lebih sederhana' tanpa mengulangi apa yang dimaksud dengan 'itu' — model melihat seluruh riwayat dan mengetahui hal yang Anda rujuk.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
history = [{'role': 'system', 'content': 'You are a science teacher.'}]
# Turn 1
history.append({'role': 'user', 'content': 'What is photosynthesis?'})
r1 = client.chat.completions.create(model='gpt-4o', messages=history)
reply1 = r1.choices[0].message.content
history.append({'role': 'assistant', 'content': reply1})
# Turn 2 — refers to prior answer without repeating it
history.append({'role': 'user', 'content': 'Can you explain that using only 3 bullet points?'})
r2 = client.chat.completions.create(model='gpt-4o', messages=history)
print(r2.choices[0].message.content)API Tanpa Status, UX dengan Status
Berikut wawasan penting: API sepenuhnya tanpa status. Server tidak mengingat apa pun di antara panggilan.
Produk obrolan seperti ChatGPT menciptakan ilusi memori dengan menyimpan riwayat percakapan di basis data mereka sendiri dan memasukkannya kembali ke setiap panggilan API. Anda dapat membangun mekanisme yang sama sendiri.
# Illustration: two isolated API calls vs one with history
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# ❌ WITHOUT history — model has no memory
r1 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': 'My dog is named Biscuit.'}]
)
r2 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': "What's my dog's name?"}]
)
print('Without history:', r2.choices[0].message.content) # will not know
# ✅ WITH history injected
r3 = client.chat.completions.create(
model='gpt-4o',
messages=[
{'role': 'user', 'content': 'My dog is named Biscuit.'},
{'role': 'assistant', 'content': 'Got it, your dog is named Biscuit!'},
{'role': 'user', 'content': "What's my dog's name?"}
]
)
print('With history:', r3.choices[0].message.content)Kiat Praktis Menggunakan Antarmuka Obrolan
Untuk mendapatkan manfaat maksimal dari antarmuka obrolan:
- Letakkan instruksi yang berlaku terus-menerus dalam pesan sistem, bukan mengulanginya di setiap giliran pengguna
- Buat giliran sebelumnya tetap ringkas — riwayat yang panjang menghabiskan token dengan cepat
- Mulai sesi baru saat berganti topik agar konteks tidak tercemar
- Saat melanjutkan proyek panjang, masukkan hanya bagian relevan dari konteks sebelumnya
# Good practice: compact system message + focused history
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
system = (
'You are a concise Python code reviewer. '
'Reply with: 1) one-line verdict, 2) top 3 issues, 3) fixed snippet.'
)
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=512,
system=system,
messages=[
{'role': 'user', 'content': 'def add(a,b): return a+b\nprint(add(1,2))'}
]
)
print(response.content[0].text)Rangkuman: Antarmuka Obrolan
Mari kita tinjau gagasan utama tentang cara kerja antarmuka obrolan:
- Tiga peran: sistem menetapkan aturan, pengguna mengirim perintah, asisten menjawab
- Seluruh riwayat dikirim pada setiap panggilan API — server tidak memiliki status
- Batas token membatasi total konteks; potong atau ringkas saat mendekatinya
- Konteks sesi hanyalah daftar yang Anda kelola dalam kode Anda sendiri
- Mulai sesi baru saat berganti topik agar konteks tetap bersih
# Summary: minimal chat loop skeleton
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
history = [{'role': 'system', 'content': 'You are a helpful assistant.'}]
def ask(question):
history.append({'role': 'user', 'content': question})
res = client.chat.completions.create(model='gpt-4o', messages=history)
answer = res.choices[0].message.content
history.append({'role': 'assistant', 'content': answer})
return answer
print(ask('Hello! What can you help me with?'))Uji Pemahaman
Uji pemahaman Anda tentang mekanisme antarmuka obrolan.
Seorang pengguna memulai sesi yang benar-benar baru dan bertanya kepada AI: 'Apa yang kita bicarakan kemarin?' AI tidak memiliki ingatan tentang sesi kemarin. Mengapa?
Hal yang Telah Anda Pelajari
Sekarang Anda memahami dasar setiap interaksi obrolan AI:
- Struktur peran sistem/pengguna/asisten yang membentuk setiap percakapan
- Bagaimana seluruh riwayat pesan dikirim pada setiap panggilan untuk mensimulasikan memori
- Mengapa API tanpa status dan bagaimana produk obrolan membangun memori di atasnya
- Bagaimana batas token membatasi konteks dan cara mengelolanya
Model mental ini akan membantu Anda menyusun perintah yang lebih baik dan membangun aplikasi bertenaga AI yang lebih cerdas.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Memahami Antarmuka Obrolan” gratis?
Ya — teks lengkap “Memahami Antarmuka Obrolan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Prompt Engineering, upgrade ke CoddyKit PRO. Kursus AI Prompt Engineering mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Memahami Antarmuka Obrolan”?
Pelajari cara kerja UI obrolan LLM: peran, giliran, dan konteks sesi. Kamu berlatih AI Prompt Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai AI Prompt Engineering?
Tidak diperlukan pengalaman sebelumnya. AI Prompt Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.
Berapa lama pelajaran “Memahami Antarmuka Obrolan” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Prompt Engineering ini?
Ya. Setiap pelajaran AI Prompt Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Memahami Antarmuka Obrolan
- Jenis Permintaan yang Dapat Ditangani Kecerdasan Buatan
- Cara Kecerdasan Buatan Menghasilkan Respons
- Hal yang Tidak Dapat Dilakukan Kecerdasan Buatan