Di lanskap digital yang serba cepat saat ini, dengan meningkatnya popularitas Large Language Models (LLMs), aplikasi percakapan semakin populer. Chatbot telah mengubah cara kita berinteraksi dengan aplikasi, situs web, dan bahkan kanal layanan pelanggan dalam keseharian kita.
Kemampuan untuk membangun chatbot sendiri menjadi game-changer, memberdayakan bisnis dan individu untuk menciptakan antarmuka percakapan yang dipersonalisasi, efisien, dan menarik sesuai kebutuhan spesifik mereka.
Artikel ini bertujuan mengulas cara membangun chatbot di Python dengan memanfaatkan kekuatan LLMs. Kita akan membahas cara membuat chatbot sendiri menggunakan ChatGPT dan cara mengoptimalkannya lebih lanjut dengan kerangka kerja populer LangChain.
Jika Anda baru mengenal ChatGPT dan LangChain, lihat Pengenalan Large Language Models dengan GPT & LangChain AI code-along kami di bawah ini:
Artikel ini mencakup semua aspek penting dalam pengembangan chatbot teroptimasi yang menggunakan ChatGPT sebagai model di baliknya. Kita akan menggunakan Jupyter Notebook dengan pustaka openai dan langchain terpasang. Anda dapat mengikutinya di buku kerja DataLab ini.
Pada bagian berikut, kita akan mempelajari cara menggunakan OpenAI API untuk melakukan panggilan API dasar ke ChatGPT sebagai blok bangunan percakapan kita. Selain itu, kita akan menerapkan kesadaran konteks untuk chatbot menggunakan struktur Python dasar. Terakhir, kita akan mengoptimalkan implementasi chatbot dan riwayat percakapan menggunakan LangChain dan mengeksplorasi fitur memorinya.
Panggilan API Dasar ChatGPT
Kita akan menggunakan ChatGPT sebagai model di balik chatbot kita. Karena itu, tugas praktis pertama adalah menulis panggilan API sederhana namun lengkap ke ChatGPT, agar kita dapat membangun interaksi pertama.
Fungsi Python berikut menyematkan panggilan API yang kita inginkan ke ChatGPT hanya dengan pustaka openai.
import os
import openai
openai_api_key = os.environ["OPENAI_API_KEY"]
def chatgpt_call(prompt, model="gpt-3.5-turbo"):
response = openai.ChatCompletion.create(
model=model,
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message["content"]
Perhatikan bahwa dalam kasus ini, kita menggunakan model gpt-3.5-turbo karena ini adalah model GPT-3.5 paling andal yang dioptimalkan untuk chat, sekaligus salah satu model termurah. Informasi lebih lanjut tentang berbagai model yang tersedia dapat ditemukan di dokumentasi OpenAI.
Butuh bantuan mendapatkan kunci OpenAI API Anda? Maka pelatihan Getting Started with the OpenAI API and ChatGPT cocok untuk Anda.
Mari kita analisis implementasi kita selangkah demi selangkah!
Fungsi chatgpt_call() adalah pembungkus di sekitar pemanggilan fungsi OpenAI asli ChatCompletion.create yang membuat permintaan penyelesaian chat.
Dengan prompt yang diinginkan, fungsi ini mengembalikan completion ChatGPT yang sesuai. Untuk panggilan completion yang berhasil, hanya ID model yang akan digunakan (model) dan prompt yang diinginkan (prompt) yang perlu disediakan.
Completion yang dikembalikan ChatGPT berisi metadata beserta responsnya. Namun, completion itu sendiri selalu dikembalikan pada bidang response.choices[0].message[“content”]. Informasi lebih lanjut tentang isi completion lengkap dapat ditemukan di dokumentasi OpenAI.
Dengan implementasi ini, kita dapat langsung memberi prompt ke ChatGPT dalam satu baris:
prompt = "My name is Andrea"
response = chatgpt_call(prompt)
print(response)
# Output: Nice to meet you, Andrea! How can I assist you today?
Panggilan sebagai interaksi mandiri
Apakah Anda melihat ada kekurangan pada implementasi di atas?
Sebagai petunjuk, mari lakukan interaksi lanjutan:
prompt = "Do you remember my name?"
response = chatgpt_call(prompt)
print(response)
# Output: I'm sorry, as an AI language model, I don't have the ability to remember specific information about individual users.
Tepat, seperti yang terlihat, setiap panggilan API adalah interaksi mandiri. Artinya, model tidak memiliki memori atas prompt atau completion sebelumnya. Setiap kali kita memanggil fungsi chatgpt_call(), kita memulai percakapan yang benar-benar baru.
Ini jelas menjadi masalah saat mencoba membangun chatbot, karena mustahil melakukan percakapan jika model tidak mengingat apa yang telah dibahas sejauh ini. Karena itu, langkah berikutnya adalah membuat model menyadari interaksi sebelumnya.
Kesadaran konteks
Kesadaran konteks memungkinkan chatbot memahami dan merespons secara tepat berdasarkan percakapan yang sedang berlangsung.
Dengan membangun konteks, interaksi berikutnya dapat dipersonalisasi berdasarkan interaksi sebelumnya, menjaga kesinambungan percakapan dan menghindari pengulangan. Selain itu, dengan chatbot yang sadar konteks, pengguna dapat secara proaktif mengajukan pertanyaan klarifikasi atau memberikan saran untuk meluruskan kesalahpahaman.
Secara keseluruhan, kesadaran konteks meningkatkan kealamian, efektivitas, dan pengalaman pengguna chatbot. Mulai sekarang, kita akan menyebut kumpulan interaksi sebelumnya sebagai riwayat percakapan atau memori.
OpenAI API asli untuk ChatGPT sudah menyediakan cara untuk mengirim riwayat percakapan kita ke model bersama setiap prompt baru. Selain itu, kerangka kerja LangChain juga menyediakan cara untuk mengelola memori ChatGPT secara lebih efektif dan hemat biaya.
Memahami Pesan System, Assistant, dan User
Struktur riwayat percakapan ChatGPT
Pada titik ini, kita dapat langsung menggunakan metode chatgpt_call() hanya dengan memberikan prompt yang diinginkan. Jika kita melihat implementasinya lebih dekat, prompt input diformat sebagai bagian dari daftar messages. Daftar ini sebenarnya dimaksudkan untuk melacak riwayat percakapan, dan karenanya harus diformat dengan cara yang sangat khusus.
Mari kita lihat lebih dekat!
Sejauh ini, kita telah memformat daftar messages di chatgpt_call() sebagai berikut:
messages = [{"role": "user", "content": prompt}]
Daftar messages menyimpan riwayat percakapan sebagai kumpulan dictionary. Setiap dictionary dalam daftar mewakili sebuah pesan dalam percakapan dengan menggunakan dua pasangan kunci-nilai.
- Kunci
roledengan nilaiusermenunjukkan bahwa pesan dikirim oleh pengguna. - Kunci
contentdengan nilaipromptmemuat prompt pengguna yang sebenarnya.
Ini adalah contoh yang sangat sederhana yang hanya berisi satu interaksi. Meskipun kunci content akan selalu menyimpan prompt pengguna atau completion chatbot, kunci role jauh lebih fleksibel.
Peran System, Assistant, dan User
Kunci role menunjukkan pemilik pesan di content. Saat menggunakan ChatGPT, kita dapat memiliki hingga tiga peran:
- User. Seperti yang telah dibahas, peran
usermerujuk pada pengguna yang berinteraksi dengan chatbot. - Assistant. Peran
assistantmerujuk pada chatbot. - System. Peran
systemdigunakan untuk memberikan instruksi, panduan, dan konteks kepada chatbot. Pesan sistem membantu mengarahkan interaksi pengguna, menetapkan perilaku chatbot, memberi informasi kontekstual, dan menangani interaksi tertentu dalam percakapan. Pesan sistem dapat dianggap sebagai instruksi tingkat tinggi untuk chatbot, yang transparan bagi pengguna.
Gambar buatan sendiri. Interaksi berbagai peran dalam rantai percakapan saat membangun chatbot dengan chatGPT.
Membangun Riwayat Percakapan
Kita dapat mulai membangun riwayat percakapan dengan memanfaatkan tiga peran user, assistant, dan system dalam daftar messages kita.
Berdasarkan interaksi uji kita, riwayat percakapan yang diformat dengan benar menggunakan ketiga peran tersebut dapat terlihat sebagai berikut:
messages = [
{'role':'system', 'content':'You are friendly chatbot.'},
{'role':'user', 'content':'Hi, my name is Andrea'},
{'role':'assistant', 'content': "Nice to meet you, Andrea! How can I assist you today?"},
{'role':'user', 'content':'Do you remember my name?'} ]
Kita dapat sedikit memodifikasi fungsi call_chatgpt() untuk menyertakan riwayat percakapan sebagai parameter input:
def call_chatgpt_with_memory(messages, model="gpt-3.5-turbo"):
response = openai.ChatCompletion.create(
model=model,
messages=messages,
)
return response.choices[0].message["content"]
Mari coba implementasi baru ini!
messages = [
{'role':'system', 'content':'You are friendly chatbot.'},
{'role':'user', 'content':'Hi, my name is Andrea'},
{'role':'assistant', 'content': "Nice to meet you, Andrea! How can I assist you today?"},
{'role':'user', 'content':'Do you remember my name?'} ]
response = call_chatgpt_with_memory(messages)
print(response)
# Output: Yes, your name is Andrea.
Bagus! Kita berhasil membuat model menyadari interaksi sebelumnya sehingga kita benar-benar bisa bercakap dengan model. Namun, kita perlu menemukan cara untuk memperbarui daftar messages secara otomatis.
Riwayat percakapan otomatis
Kita dapat mencapai pengumpulan pesan secara otomatis dengan mengembangkan sedikit lebih jauh fungsi panggilan API kita:
def chatgpt_conversation(prompt):
context.append({'role':'user', 'content':f"{prompt}"})
response = call_chatgpt_with_memory(context)
context.append({'role':'assistant',
'content':f"{response}"})
return response
Sekarang mari kita coba!
chatgpt_conversation("Hello, my name is Andrea")
# Output: 'Nice to meet you, Andrea! How can I assist you today?'
Dan interaksi lanjutan:
chatgpt_conversation("Do you remember my name?")
# Output: 'Yes, your name is Andrea.'
Kini riwayat percakapan diperbarui secara otomatis. Terakhir, perhatikan bahwa Anda dapat melihat riwayat percakapan—dan strukturnya—kapan saja hanya dengan mencetak daftar messages.
print(messages)
# Output:
[{'role': 'user', 'content': 'Hello, my name is Andrea'},
{'role': 'assistant', 'content': 'Nice to meet you, Andrea! How can I assist you today?'},
{'role': 'user', 'content': 'Do you remember my name?'},
{'role': 'assistant', 'content': 'Yes, your name is Andrea.'}]
Kerangka Kerja LangChain
Sampai titik ini, kita sepakat bahwa implementasi kita menghasilkan chatbot yang berguna, tetapi mungkin belum merupakan versi yang paling optimal.
Terus-menerus memasukkan setiap prompt dan completion sebelumnya dapat dengan cepat menghasilkan kumpulan token yang sangat besar, dan ChatGPT harus memproses semuanya sebelum mengembalikan completion terbaru.
Sejauh ini, kita menggunakan operasi .append untuk menggabungkan interaksi masa lalu agar chatbot memiliki semacam memori. Namun, pengelolaan memori dapat dilakukan dengan lebih efektif menggunakan paket khusus seperti LangChain.
LangChain adalah kerangka kerja untuk mengembangkan aplikasi yang didukung oleh model bahasa. Karena chatbot adalah salah satu aplikasi paling populer saat ini, LangChain menyediakan implementasi yang lebih rapi untuk membangun riwayat percakapan chatbot, serta alternatif lain untuk menanganinya secara lebih efisien.
Untuk informasi lebih lanjut tentang kerangka kerja LangChain itu sendiri, saya sangat merekomendasikan artikel pengantar Introduction to LangChain for Data Engineering & Data Applications.
Riwayat percakapan sederhana dengan LangChain
Di bagian ini, kita akan mempelajari cara menggunakan Kerangka Kerja LangChain untuk membangun chatbot.
Pustaka langchain berfungsi sebagai pengganti pustaka openai yang digunakan di atas, karena modul langchain.llms sudah memungkinkan Anda berinteraksi dengan ChatGPT hanya dengan dua baris kode:
# OpenAI key from environment
from langchain.llms import OpenAI
llm = OpenAI()Setelah model llm dimuat, mari impor objek memori yang akan menyimpan riwayat percakapan kita. Untuk menyimpan setiap interaksi masa lalu dengan chatbot, LangChain menyediakan ConversationBufferMemory:
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
Sekarang saatnya mengimpor ConversationChain, sebagai pembungkus yang akan memanfaatkan llm dan memory untuk mengirim prompt pengguna ke ChatGPT dan mengembalikan completion-nya:
from langchain.chains import ConversationChain
conversation = ConversationChain(
llm=llm,
memory=memory
)
Akhirnya, untuk mengirimkan prompt pengguna ke ChatGPT, kita dapat menggunakan metode .predict sebagai berikut:
conversation.predict(input="Hello, my name is Andrea")
# Output: "Hi Andrea, I'm an AI created to help you with whatever you may need. What can I do for you today?"
Mari atur verbose=True untuk melihat informasi yang dipertimbangkan model saat memberikan completion. Coba pada interaksi lanjutan:
Tangkapan layar konteks yang tersedia untuk ChatGPT saat membuat completion. Keluaran verbose berwarna hijau.
Terakhir, mari cek bahwa ia mengingat interaksi sebelumnya dengan sempurna:
Tangkapan layar konteks yang tersedia untuk ChatGPT saat membuat completion. Keluaran verbose berwarna hijau.
Mengisi riwayat percakapan
Kita dapat memberi konteks tambahan ke chatbot menggunakan metode memory.save_context(). Dengan cara ini, kita dapat membuat chatbot menyadari konten apa pun tanpa perlu memberikan informasi ini dalam percakapan. Di LangChain, kata kunci untuk tujuan ini adalah input dan output. Contohnya,
memory.save_context({"input": "Hi"},
{"output": "What's up"})
memory.save_context({"input": "Not much, just hanging"},
{"output": "Cool"})
Selain itu, kita juga dapat mengecek isi memori kapan saja dengan menjalankan print(memory.buffer) atau memory.load_memory_variables({}).
Jenis Memori di LangChain
LangChain mengimplementasikan berbagai tipe memori untuk ChatGPT. ConversationBufferMemory yang digunakan di atas melacak setiap interaksi dengan ChatGPT. Namun, kita sudah membahas bahwa memberi prompt ke ChatGPT dengan seluruh riwayat percakapan dapat dengan cepat meningkat menjadi jumlah token yang sangat besar untuk diproses pada setiap interaksi baru.
Perlu diingat bahwa selain batas token per interaksi, biaya penggunaan ChatGPT juga bergantung pada jumlah token. Memproses seluruh riwayat percakapan pada setiap interaksi baru kemungkinan akan mahal seiring waktu.
Untuk menghindari pemrosesan terus-menerus atas riwayat percakapan, LangChain mengimplementasikan cara lain yang dioptimalkan untuk mengelola memori ChatGPT. Kita akan mengeksplorasi salah satu tipe paling canggih pada bagian berikut.
Riwayat percakapan tingkat lanjut dengan LangChain
Cara tingkat lanjut untuk mengelola memori tanpa menyimpan setiap interaksi masa lalu adalah dengan menyimpan ringkasan interaksi.
Jenis memori ini adalah favorit saya karena benar-benar dapat menghasilkan pengelolaan memori yang optimal, tanpa mengorbankan interaksi masa lalu.
Mari kita coba!
# OpenAI key from environment
from langchain.llms import OpenAI
llm = OpenAI()
from langchain.memory import ConversationSummaryBufferMemory
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
Perhatikan bahwa jenis memori ini menggunakan llm yang didefinisikan untuk menghasilkan ringkasan interaksi sebelumnya.
Selain itu, memori ini dapat menyimpan interaksi lengkap hingga jumlah token maksimum (max_token_limit). Di atas batas ini, ia memasukkan informasi dari pesan-pesan tersebut ke dalam ringkasan.
Untuk mengujinya, mari buat interaksi dengan jumlah token yang besar. Pertimbangkan schedule berikut:
schedule = "There is a meeting at 8am with your product team. \
You will need your powerpoint presentation prepared. \
9am-12pm have time to work on your LangChain \
project which will go quickly because Langchain is such a powerful tool. \
At Noon, lunch at the italian resturant with a customer who is driving \
from over an hour away to meet you to understand the latest in AI. \
Be sure to bring your laptop to show the latest LLM demo."
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
memory.save_context({"input": "Hello"}, {"output": "What's up"})
memory.save_context({"input": "Not much, just hanging"}, {"output": "Cool"})
memory.save_context({"input": "What is on the schedule today?"}, {"output": f"{schedule}"})
Sekarang, kita hanya perlu mendeklarasikan rantai percakapan baru dengan llm dan memory seperti pada contoh sebelumnya.
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True
)
Kita dapat menggunakan .predict untuk memberi prompt ke ChatGPT:
Tangkapan layar konteks yang tersedia untuk ChatGPT saat membuat completion. Keluaran verbose berwarna hijau.
Seperti yang dapat kita lihat, chatbot menyimpan ringkasan riwayat percakapan asli, mengurangi jumlah token yang diproses ChatGPT pada setiap interaksi lanjutan.
Itu saja! Sekarang kita bisa terus berbincang dengan chatbot teroptimasi ini selama berjam-jam!
Atur verbose=False untuk mendapatkan pengalaman tanya jawab yang lebih nyaman di notebook Anda.
Kesimpulan
Dalam artikel ini, kita telah melihat cara membangun chatbot yang sadar konteks menggunakan model ChatGPT yang terkenal.
Kita telah melihat bagaimana membangun chatbot sadar konteks dapat menghasilkan interaksi berkelanjutan. Pendekatan iteratif ini membangun loop umpan balik yang konstan, memungkinkan Anda menjaga kebutuhan dan preferensi pengguna sepanjang percakapan.
Kita telah melihat dua pendekatan utama untuk mengelola riwayat percakapan chatbot. Pertama, menggunakan ChatGPT API asli yang menghasilkan chatbot native yang fungsional. Kedua, menggunakan kerangka kerja LangChain dan implementasi tipe memori yang dioptimalkan.
Sekarang giliran Anda! Saatnya menggunakan blok bangunan yang disajikan dalam artikel ini untuk menyesuaikan chatbot yang sesuai dengan kasus penggunaan spesifik Anda!
Jika Anda tertarik membangun aplikasi lain menggunakan LangChain dan ChatGPT, webinar Building AI Applications with LangChain and GPT cocok untuk Anda. Ingin cepat mahir di NLP? Maka lihat modul Natural Language Processing in Python!
