🚀 Coba Zilliz Cloud, Milvus yang sepenuhnya terkelola, secara gratis—rasakan performa 10x lebih cepat! Coba Sekarang>>

milvus-logo
LFAI

Memori Percakapan di LangChain

  • Engineering
June 06, 2023
Yujian Tang

LangChain adalah kerangka kerja yang kuat untuk membangun aplikasi LLM. Namun, dengan kekuatan itu, ada sedikit kerumitan. LangChain menyediakan banyak cara untuk meminta LLM dan fitur-fitur penting seperti memori percakapan. Memori percakapan menawarkan konteks bagi LLM untuk mengingat obrolan Anda.

Dalam tulisan ini, kita akan melihat bagaimana cara menggunakan memori percakapan dengan LangChain dan Milvus. Untuk mengikutinya, Anda perlu pip menginstal empat pustaka dan kunci API OpenAI. Empat library yang Anda butuhkan dapat diinstal dengan menjalankan pip install langchain milvus pymilvus python-dotenv. Atau menjalankan blok pertama di Notebook CoLab untuk artikel ini.

Dalam tulisan ini, kita akan belajar tentang:

  • Memori Percakapan dengan LangChain
  • Menyiapkan Konteks Percakapan
  • Meminta Memori Percakapan dengan LangChain
  • Rangkuman Memori Percakapan LangChain

Memori Percakapan dengan LangChain

Dalam kondisi default, Anda berinteraksi dengan LLM melalui satu perintah. Menambahkan memori untuk konteks, atau "memori percakapan" berarti Anda tidak perlu lagi mengirim semuanya melalui satu prompt. LangChain menawarkan kemampuan untuk menyimpan percakapan yang telah Anda lakukan dengan LLM untuk mengambil informasi tersebut di kemudian hari.

Untuk mengatur memori percakapan yang persisten dengan penyimpanan vektor, kita membutuhkan enam modul dari LangChain. Pertama, kita harus mendapatkan OpenAIEmbeddings dan OpenAI LLM. Kita juga membutuhkan VectorStoreRetrieverMemory dan versi LangChain dari Milvus untuk menggunakan backend penyimpanan vektor. Kemudian kita membutuhkan ConversationChain dan PromptTemplate untuk menyimpan percakapan kita dan menanyakannya.

Pustaka os, dotenv, dan openai terutama untuk tujuan operasional. Kita menggunakannya untuk memuat dan menggunakan kunci API OpenAI. Langkah penyiapan terakhir adalah menjalankan instance Milvus Lite lokal. Kita melakukan ini dengan menggunakan default_server dari paket Milvus Python.

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain.vectorstores import Milvus
embeddings = OpenAIEmbeddings()


import os
from dotenv import load_dotenv
import openai
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")


from milvus import default_server
default_server.start()

Menyiapkan Konteks Percakapan

Setelah semua prasyarat disiapkan, kita dapat melanjutkan untuk membuat memori percakapan. Langkah pertama kita adalah membuat koneksi ke server Milvus menggunakan LangChain. Selanjutnya, kita menggunakan kamus kosong untuk membuat koleksi LangChain Milvus. Sebagai tambahan, kita memasukkan embedding yang kita buat di atas dan detail koneksi untuk server Milvus Lite.

Untuk menggunakan basis data vektor untuk memori percakapan, kita perlu menginstansikannya sebagai retriever. Kita hanya mengambil 1 hasil teratas untuk kasus ini, dengan pengaturan k=1. Langkah pengaturan memori percakapan terakhir adalah menggunakan objek VectorStoreRetrieverMemory sebagai memori percakapan kita melalui koneksi retriever dan basis data vektor yang baru saja kita siapkan.

Untuk menggunakan memori percakapan kita, memori ini harus memiliki beberapa konteks di dalamnya. Jadi, mari kita berikan beberapa konteks pada memori tersebut. Untuk contoh ini, kita memberikan lima informasi. Mari kita simpan camilan favorit saya (cokelat), olahraga (berenang), bir (Guinness), makanan penutup (kue keju), dan musisi (Taylor Swift). Setiap entri disimpan ke memori melalui fungsi save_context.

vectordb = Milvus.from_documents(
   {},
   embeddings,
   connection_args={"host": "127.0.0.1", "port": default_server.listen_port})
retriever = Milvus.as_retriever(vectordb, search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
   {"input": "My favorite snack is chocolate",
    "output": "Nice"},
   {"input": "My favorite sport is swimming",
    "output": "Cool"},
   {"input": "My favorite beer is Guinness",
    "output": "Great"},
   {"input": "My favorite dessert is cheesecake",
    "output": "Good to know"},
   {"input": "My favorite musician is Taylor Swift",
    "output": "Same"}
]
for example in about_me:
   memory.save_context({"input": example["input"]}, {"output": example["output"]})

Meminta Memori Percakapan dengan LangChain

Saatnya untuk melihat bagaimana kita dapat menggunakan memori percakapan kita. Mari kita mulai dengan menghubungkan ke OpenAI LLM melalui LangChain. Kita menggunakan suhu 0 untuk mengindikasikan bahwa kita tidak ingin LLM kita menjadi kreatif.

Selanjutnya, kita membuat sebuah template. Kita memberi tahu LLM bahwa ia terlibat dalam percakapan ramah dengan manusia dan menyisipkan dua variabel. Variabel history menyediakan konteks dari memori percakapan. Variabel input menyediakan input saat ini. Kita menggunakan objek PromptTemplate untuk memasukkan variabel-variabel ini.

Kita menggunakan objek ConversationChain untuk menggabungkan prompt, LLM, dan memori. Sekarang kita siap untuk memeriksa memori percakapan kita dengan memberikan beberapa prompt. Kita mulai dengan memberi tahu LLM bahwa nama kita adalah Gary, saingan utama dalam seri Pokemon (semua yang lain dalam memori percakapan adalah fakta tentang saya).

llm = OpenAI(temperature=0) # Can be any valid LLM
_DEFAULT_TEMPLATE = """The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.


Relevant pieces of previous conversation:
{history}


(You do not need to use these pieces of information if not relevant)


Current conversation:
Human: {input}
AI:"""
PROMPT = PromptTemplate(
   input_variables=["history", "input"], template=_DEFAULT_TEMPLATE
)
conversation_with_summary = ConversationChain(
   llm=llm,
   prompt=PROMPT,
   memory=memory,
   verbose=True
)
conversation_with_summary.predict(input="Hi, my name is Gary, what's up?")

Gambar di bawah ini menunjukkan seperti apa respon yang diharapkan dari LLM. Dalam contoh ini, LLM merespons dengan mengatakan bahwa namanya adalah "AI".

Sekarang mari kita uji memori sejauh ini. Kita gunakan objek ConversationChain yang telah kita buat sebelumnya dan menanyakan musisi favorit saya.

conversation_with_summary.predict(input="who is my favorite musician?")

Gambar di bawah ini menunjukkan respons yang diharapkan dari Rantai Percakapan. Karena kita menggunakan opsi verbose, maka ia juga menunjukkan kepada kita percakapan yang relevan. Kita dapat melihat bahwa ia mengembalikan bahwa artis favorit saya adalah Taylor Swift, seperti yang diharapkan.

Selanjutnya, mari kita periksa makanan penutup favorit saya - kue keju.

conversation_with_summary.predict(input="Whats my favorite dessert?")

Ketika kita menanyakan makanan penutup favorit saya, kita dapat melihat bahwa Rantai Percakapan sekali lagi mengambil informasi yang benar dari Milvus. Ia menemukan bahwa makanan penutup favorit saya adalah cheesecake, seperti yang saya katakan sebelumnya.

Sekarang setelah kita mengonfirmasi bahwa kita dapat meminta informasi yang kita berikan sebelumnya, mari kita periksa satu hal lagi - informasi yang kita berikan di awal percakapan. Kami memulai percakapan kami dengan memberi tahu AI bahwa nama kami adalah Gary.

conversation_with_summary.predict(input="What's my name?")

Pemeriksaan terakhir kami menunjukkan bahwa rantai percakapan menyimpan sedikit informasi tentang nama kita di memori percakapan penyimpanan vektor. Rantai percakapan tersebut mengembalikan bahwa nama kita adalah Gary.

Ringkasan Memori Percakapan Rantai Bahasa

Dalam tutorial ini, kita telah belajar bagaimana menggunakan memori percakapan di LangChain. LangChain menawarkan akses ke backend penyimpanan vektor seperti Milvus untuk memori percakapan yang persisten. Kita dapat menggunakan memori percakapan dengan menyuntikkan riwayat ke dalam permintaan kita dan menyimpan konteks historis di objek ConversationChain.

Untuk contoh tutorial ini, kami memberikan Rantai Percakapan lima fakta tentang saya dan berpura-pura menjadi saingan utama di Pokemon, Gary. Kemudian, kami mem-ping Rantai Percakapan dengan pertanyaan tentang pengetahuan apriori yang kami simpan - musisi dan makanan penutup favorit saya. Ia menjawab kedua pertanyaan ini dengan benar dan memunculkan entri yang relevan. Terakhir, kami bertanya tentang nama kami seperti yang diberikan di awal percakapan, dan dengan benar menjawab bahwa nama kami adalah "Gary."

Like the article? Spread the word

Terus Baca