Rekayasa prompt
Rekayasa Prompt dari Nol hingga Tingkat Lanjut dengan LangChain di Python

Poin utamaLangChain menstandarisasi integrasi LLM dengan arsitektur modular yang terdiri dari…
Lihat selengkapnya
- LangChain menstandarisasi integrasi LLM dengan arsitektur modular yang terdiri dari rantai (chains), agen, dan memori.
- Rekayasa prompt lanjutan dengan LangChain menggunakan templat terstruktur dan pola seperti ReAct untuk memandu penalaran model.
- LangChain mengatasi keterbatasan LLM dengan menghubungkan model ke alat eksternal dan sumber data melalui agen.
Aspek penting dari Model Bahasa Besar (LLM) adalah jumlah parameter yang digunakan oleh model ini untuk belajar. Semakin banyak parameter yang dimiliki model, semakin baik model dapat memahami hubungan antara kata dan frasa. Ini berarti bahwa model dengan miliaran parameter memiliki kemampuan untuk menghasilkan berbagai format teks kreatif dan menjawab pertanyaan terbuka dan menantang dengan cara yang informatif.
LLM seperti ChatGPT, yang menggunakan model Transformer, sangat mahir dalam memahami dan menghasilkan bahasa manusia, sehingga sangat berguna untuk aplikasi yang memerlukan pemahaman bahasa alami. Namun, mereka tidak tanpa keterbatasan, termasuk pengetahuan yang sudah ketinggalan zaman, ketidakmampuan untuk berinteraksi dengan sistem eksternal, kurangnya pemahaman konteks, dan terkadang menghasilkan respons yang terdengar masuk akal tetapi salah atau tidak masuk akal, di antara lainnya.
Untuk mengatasi keterbatasan ini, diperlukan integrasi LLM dengan sumber data dan kemampuan eksternal, yang dapat menimbulkan kompleksitas dan memerlukan keterampilan pemrograman dan pengolahan data yang luas. Ini, dikombinasikan dengan tantangan memahami konsep AI dan algoritma yang kompleks, menyumbang pada kurva belajar yang terkait dengan pengembangan aplikasi menggunakan LLM.
Namun, integrasi LLM dengan alat lain untuk membentuk aplikasi yang ditenagai LLM dapat mengubah lanskap digital kita. Potensi aplikasi tersebut sangat luas, termasuk meningkatkan efisiensi dan produktivitas, menyederhanakan tugas, meningkatkan pengambilan keputusan, dan menyediakan pengalaman yang dipersonalisasi.
Dalam artikel ini, kita akan membahas lebih dalam tentang masalah-masalah ini, menjelajahi teknik-teknik lanjutan dari teknik prompt engineering dengan Langchain, menawarkan penjelasan yang jelas, contoh praktis, dan instruksi langkah demi langkah tentang cara menerapkannya.
Langchain, sebuah pustaka perangkat lunak yang sangat mutakhir, membawa kemudahan dan fleksibilitas dalam merancang, menerapkan, dan mengoptimalkan prompt. Ketika kita membongkar prinsip-prinsip dan praktik teknik prompt engineering, Anda akan belajar bagaimana menggunakan fitur-fitur kuat Langchain untuk memanfaatkan kekuatan model AI Generatif terbaru seperti GPT-4.
Mengenal Prompt
Sebelum memasuki teknisnya teknik prompt engineering, penting untuk memahami konsep prompt dan signifikansinya.
Sebuah ‘prompt‘ adalah urutan token yang digunakan sebagai input untuk model bahasa, yang memberi instruksi untuk menghasilkan jenis respons tertentu. Prompt memainkan peran kunci dalam mengarahkan perilaku model. Mereka dapat mempengaruhi kualitas teks yang dihasilkan, dan ketika dirancang dengan benar, dapat membantu model memberikan hasil yang mendalam, akurat, dan spesifik konteks.
Teknik prompt engineering adalah seni dan ilmu merancang prompt yang efektif. Tujuannya adalah untuk memicu output yang diinginkan dari model bahasa. Dengan memilih dan merancang prompt dengan hati-hati, seseorang dapat mengarahkan model untuk menghasilkan respons yang lebih akurat dan relevan. Dalam prakteknya, ini melibatkan penyesuaian frasa input untuk menyesuaikan dengan bias struktural dan pelatihan model.
Kecanggihan teknik prompt engineering berkisar dari teknik sederhana, seperti memberi model dengan kata kunci yang relevan, hingga metode yang lebih maju yang melibatkan perancangan prompt yang kompleks dan terstruktur yang menggunakan mekanisme internal model untuk keuntungannya.
LangChain: Alat Prompt dengan Pertumbuhan Tercepat
LangChain, yang diluncurkan pada Oktober 2022 oleh Harrison Chase, telah menjadi salah satu kerangka kerja open-source yang paling dinilai tinggi di GitHub pada 2023. Ini menawarkan antarmuka yang disederhanakan dan standar untuk mengintegrasikan Model Bahasa Besar (LLM) ke dalam aplikasi. Ini juga menyediakan antarmuka yang kaya fitur untuk teknik prompt engineering, memungkinkan pengembang untuk bereksperimen dengan strategi yang berbeda dan mengevaluasi hasilnya. Dengan menggunakan Langchain, Anda dapat melakukan tugas teknik prompt engineering dengan lebih efektif dan intuitif.
LangFlow berfungsi sebagai antarmuka pengguna untuk mengatur komponen LangChain menjadi flowchart yang dapat dieksekusi, memungkinkan prototip dan eksperimen yang cepat.

LangChain mengisi celah penting dalam pengembangan AI untuk massa. Ini memungkinkan berbagai aplikasi NLP seperti asisten virtual, generator konten, sistem pertanyaan dan jawaban, dan lainnya, untuk menyelesaikan berbagai masalah dunia nyata.
Bukan sebagai model atau penyedia mandiri, LangChain menyederhanakan interaksi dengan model yang beragam, memperluas kemampuan aplikasi LLM di luar keterbatasan panggilan API sederhana.
Arsitektur LangChain
Komponen utama LangChain termasuk Model I/O, Prompt Templates, Memory, Agents, dan Chains.
Model I/O
LangChain memfasilitasi koneksi yang mulus dengan berbagai model bahasa dengan membungkusnya dengan antarmuka standar yang dikenal sebagai Model I/O. Ini memungkinkan peralihan model yang mudah untuk optimasi atau kinerja yang lebih baik. LangChain mendukung berbagai penyedia model bahasa, termasuk OpenAI, HuggingFace, Azure, Fireworks, dan lainnya.
Prompt Templates
Ini digunakan untuk mengelola dan mengoptimalkan interaksi dengan LLM dengan menyediakan instruksi atau contoh yang ringkas. Mengoptimalkan prompt meningkatkan kinerja model, dan fleksibilitas mereka memberikan kontribusi signifikan pada proses input.
Contoh sederhana dari template prompt:
from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))
Ketika kita maju dalam kompleksitas, kita menemukan pola yang lebih canggih dalam LangChain, seperti pola Reason and Act (ReAct). ReAct adalah pola vital untuk eksekusi tindakan di mana agen menugaskan tugas ke alat yang sesuai, menyesuaikan input untuk itu, dan mengurai outputnya untuk menyelesaikan tugas. Contoh Python di bawah ini menunjukkan pola ReAct. Ini menunjukkan bagaimana prompt dirancang di LangChain, menggunakan serangkaian pemikiran dan tindakan untuk memahami masalah dan menghasilkan jawaban akhir:
PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""
Memory
Memory adalah konsep kritis dalam LangChain, yang memungkinkan LLM dan alat untuk mempertahankan informasi dari waktu ke waktu. Perilaku ini meningkatkan kinerja aplikasi LangChain dengan menyimpan respons sebelumnya, interaksi pengguna, keadaan lingkungan, dan tujuan agen. Strategi ConversationBufferMemory dan ConversationBufferWindowMemory membantu melacak bagian penuh atau bagian terbaru dari percakapan. Untuk pendekatan yang lebih canggih, strategi ConversationKGMemory memungkinkan mengkodekan percakapan sebagai graf pengetahuan yang dapat diberikan kembali ke prompt atau digunakan untuk memprediksi respons tanpa memanggil LLM.
Agents
Sebuah agen berinteraksi dengan dunia dengan melakukan tindakan dan tugas. Dalam LangChain, agen menggabungkan alat dan rantai untuk eksekusi tugas. Ini dapat membangun koneksi ke dunia luar untuk pengambilan informasi untuk meningkatkan pengetahuan LLM, sehingga mengatasi keterbatasan bawaannya. Mereka dapat memutuskan untuk menyerahkan perhitungan kepada kalkulator atau interpreter Python tergantung pada situasi.
Agen dilengkapi dengan subkomponen:
- Alat: Ini adalah komponen fungsional.
- Toolkits: Koleksi alat.
- Agent Executors: Ini adalah mekanisme eksekusi yang memungkinkan memilih antara alat.
Agen dalam LangChain juga mengikuti pola Zero-shot ReAct, di mana keputusan didasarkan hanya pada deskripsi alat. Mekanisme ini dapat diperluas dengan memori untuk mempertimbangkan seluruh riwayat percakapan. Dengan ReAct, bukan meminta LLM untuk melengkapi teks, Anda dapat meminta model untuk merespons dalam loop pemikiran/tindakan/pengamatan.
Rantai
Rantai, sebagaimana namanya, adalah urutan operasi yang memungkinkan pustaka perangkat lunak LangChain untuk memproses input dan output model bahasa dengan lancar. Komponen integral ini dari LangChain secara fundamental terdiri dari tautan, yang dapat berupa rantai lain atau primitif seperti prompt, model bahasa, atau utilitas.
Bayangkan rantai sebagai sabuk konveyor di sebuah pabrik. Setiap langkah pada sabuk ini mewakili operasi tertentu, yang bisa jadi memanggil model bahasa, menerapkan fungsi Python ke teks, atau bahkan meminta model dengan cara tertentu.
LangChain mengategorikan rantainya menjadi tiga jenis: Rantai Utilitas, Rantai Generik, dan Rantai Gabungkan Dokumen. Kami akan membahas Rantai Utilitas dan Rantai Generik untuk diskusi kami.
- Rantai Utilitas dirancang khusus untuk mengekstrak jawaban yang tepat dari model bahasa untuk tugas yang didefinisikan dengan baik. Sebagai contoh, mari kita lihat LLMMathChain. Rantai utilitas ini memungkinkan model bahasa untuk melakukan perhitungan matematika. Ini menerima pertanyaan dalam bahasa alami, dan model bahasa kemudian menghasilkan potongan kode Python yang kemudian dieksekusi untuk menghasilkan jawaban.
- Rantai Generik, di sisi lain, berfungsi sebagai blok bangunan untuk rantai lain tetapi tidak dapat digunakan secara mandiri. Rantai ini, seperti LLMChain, adalah fondasi dan sering digabungkan dengan rantai lain untuk menyelesaikan tugas yang kompleks. Sebagai contoh, LLMChain sering digunakan untuk mengquery objek model bahasa dengan memformat input berdasarkan template prompt yang diberikan dan kemudian melewatinya ke model bahasa.
Implementasi Langkah demi Langkah dari Teknik Prompt Engineering dengan Langchain
Kami akan memandu Anda melalui proses implementasi teknik prompt engineering menggunakan Langchain. Sebelum melanjutkan, pastikan Anda telah menginstal perangkat lunak dan paket yang diperlukan.
Anda dapat menggunakan alat populer seperti Docker, Conda, Pip, dan Poetry untuk mengatur LangChain. File instalasi yang relevan untuk setiap metode ini dapat ditemukan dalam repositori LangChain di https://github.com/benman1/generative_ai_with_langchain. Ini termasuk Dockerfile untuk Docker, requirements.txt untuk Pip, pyproject.toml untuk Poetry, dan file langchain_ai.yml untuk Conda.
Dalam artikel ini, kita akan menggunakan Pip, pengelola paket standar untuk Python, untuk memfasilitasi instalasi dan pengelolaan pustaka perangkat lunak pihak ketiga. Jika tidak termasuk dalam distribusi Python Anda, Anda dapat menginstal Pip dengan mengikuti instruksi di https://pip.pypa.io/.
Untuk menginstal pustaka perangkat lunak dengan Pip, gunakan perintah pip install library_name.
Namun, Pip tidak mengelola lingkungan secara mandiri. Untuk menangani lingkungan yang berbeda, kita menggunakan alat virtualenv.
Dalam bagian berikutnya, kita akan membahas integrasi model.
Langkah 1: Mengatur Langchain
Pertama, Anda perlu menginstal paket Langchain. Kami menggunakan Windows OS. Jalankan perintah berikut di terminal Anda untuk menginstalnya:
pip install langchain
Langkah 2: Mengimpor Langchain dan Modul Lain yang Diperlukan
Selanjutnya, impor Langchain bersama dengan modul lain yang diperlukan. Di sini, kita juga mengimpor pustaka perangkat lunak transformers, yang secara luas digunakan dalam tugas NLP.
import langchain from transformers import AutoModelWithLMHead, AutoTokenizer
Langkah 3: Memuat Model Pra-pelatihan
Open AI
OpenAI model dapat diakses dengan mudah melalui pustaka perangkat lunak LangChain atau klien Python OpenAI. Terutama, OpenAI menyediakan kelas Embedding untuk model embedding teks. Dua model LLM kunci adalah GPT-3.5 dan GPT-4, yang berbeda terutama dalam panjang token. Harga untuk setiap model dapat ditemukan di situs web OpenAI. Sementara ada model yang lebih canggih seperti GPT-4-32K yang memiliki penerimaan token yang lebih tinggi, ketersediaannya melalui API tidak selalu dijamin.

Mengakses model ini memerlukan kunci API OpenAI. Ini dapat dilakukan dengan membuat akun di platform OpenAI, mengatur informasi penagihan, dan menghasilkan kunci rahasia baru.
import os os.environ["OPENAI_API_KEY"] = 'your-openai-token'
Setelah membuat kunci, Anda dapat mengatur kunci sebagai variabel lingkungan (OPENAI_API_KEY) atau melewatinya sebagai parameter selama instansiasi kelas untuk panggilan OpenAI.
Pertimbangkan skrip LangChain untuk menunjukkan interaksi dengan model OpenAI:
from langchain.llms import OpenAI llm = OpenAI(model_name="text-davinci-003") # The LLM takes a prompt as an input and outputs a completion prompt = "who is the president of the United States of America?" completion = llm(prompt)
The current President of the United States of America is Joe Biden.
Dalam contoh ini, agen diinisialisasi untuk melakukan perhitungan. Agen mengambil input, tugas penjumlahan sederhana, memprosesnya menggunakan model OpenAI yang disediakan, dan mengembalikan hasilnya.
Hugging
Hugging Face adalah pustaka perangkat lunak Transformers Python yang BEbas DIGUNAKAN, kompatibel dengan PyTorch, TensorFlow, dan JAX, dan termasuk implementasi model seperti BERT, T5, dll.
Hugging Face juga menawarkan Hugging Face Hub, platform untuk hosting repositori kode, model pembelajaran mesin, dataset, dan aplikasi web.
Untuk menggunakan Hugging Face sebagai penyedia model, Anda memerlukan akun dan kunci API, yang dapat diperoleh dari situs web mereka. Token dapat dibuat tersedia di lingkungan Anda sebagai HUGGINGFACEHUB_API_TOKEN.
Pertimbangkan cuplikan Python berikut yang menggunakan model open-source yang dikembangkan oleh Google (GOOGL ), model Flan-T5-XXL:
from langchain.llms import HuggingFaceHub
llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "In which country is Tokyo?"
completion = llm(prompt)
print(completion)
Skrip ini mengambil pertanyaan sebagai input dan mengembalikan jawaban, menunjukkan kemampuan pengetahuan dan prediksi model.
Langkah 4: Teknik Prompt Engineering Dasar
Untuk memulai, kita akan menghasilkan prompt sederhana dan melihat bagaimana model merespons.
prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))
Dalam cuplikan kode di atas, kita memberikan prompt untuk menerjemahkan teks Inggris ke dalam bahasa Prancis. Model bahasa kemudian mencoba menerjemahkan teks yang diberikan berdasarkan prompt.
Langkah 5: Teknik Prompt Engineering Lanjutan
Sementara pendekatan di atas berfungsi, itu tidak sepenuhnya memanfaatkan kekuatan teknik prompt engineering. Mari kita tingkatkan dengan memperkenalkan struktur prompt yang lebih kompleks.
prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))
Dalam cuplikan kode ini, kita memodifikasi prompt untuk menunjukkan bahwa terjemahan dilakukan oleh ‘penerjemah Prancis yang sangat terampil’. Perubahan pada prompt dapat menghasilkan terjemahan yang lebih baik, karena model sekarang mengasumsikan persona ahli.
Membangun Sistem Pertanyaan dan Jawaban Literatur Akademis dengan Langchain
Kita akan membangun sistem pertanyaan dan jawaban literatur akademis menggunakan LangChain yang dapat menjawab pertanyaan tentang makalah akademis yang diterbitkan baru-baru ini.

Pertama, untuk mengatur lingkungan kita, kita menginstal dependensi yang diperlukan.
pip install langchain arxiv openai transformers faiss-cpu
Setelah instalasi, kita membuat notebook Python baru dan mengimpor pustaka perangkat lunak yang diperlukan:
from langchain.llms import OpenAI from langchain.chains.qa_with_sources import load_qa_with_sources_chain from langchain.docstore.document import Document import arxiv
Inti dari sistem pertanyaan dan jawaban kita adalah kemampuan untuk mengambil makalah akademis yang relevan terkait dengan bidang tertentu, di sini kita mempertimbangkan Pengolahan Bahasa Alami (NLP), menggunakan database akademis arXiv. Untuk melakukan ini, kita mendefinisikan fungsi get_arxiv_data(max_results=10). Fungsi ini mengumpulkan ringkasan makalah NLP terbaru dari arXiv dan mengemasnya menjadi objek Dokumen LangChain, menggunakan ringkasan sebagai konten dan ID entri unik sebagai sumber.
Kita akan menggunakan API arXiv untuk mengambil makalah terbaru terkait NLP:
def get_arxiv_data(max_results=10):
search = arxiv.Search(
query="NLP",
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)
documents = []
for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={"source": result.entry_id},
))
return documents
Fungsi ini mengambil ringkasan makalah NLP terbaru dari arXiv dan mengubahnya menjadi objek Dokumen LangChain. Kita menggunakan ringkasan makalah dan ID entri unik (URL ke makalah) sebagai konten dan sumber, masing-masing.
def print_answer(question):
print(
chain(
{
"input_documents": sources,
"question": question,
},
return_only_outputs=True,
)["output_text"]
)
Mari kita tentukan corpus kita dan mengatur LangChain:
sources = get_arxiv_data(2) chain = load_qa_with_sources_chain(OpenAI(temperature=0))
Dengan sistem pertanyaan dan jawaban akademis kita sekarang siap, kita dapat mengujinya dengan mengajukan pertanyaan:
print_answer("What are the recent advancements in NLP?")
Outputnya akan menjadi jawaban untuk pertanyaan Anda, dengan menyebutkan sumber dari mana informasi tersebut diperoleh. Sebagai contoh:
Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1
Anda dapat dengan mudah beralih antara model atau mengubah sistem sesuai kebutuhan. Sebagai contoh, di sini kita beralih ke GPT-4 yang menghasilkan respons yang jauh lebih baik dan terperinci.
sources = get_arxiv_data(2) chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))
Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm. SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1
Token dalam GPT-4 dapat sependek satu karakter atau sepanjang satu kata. Sebagai contoh, GPT-4-32K dapat memproses hingga 32.000 token dalam satu jalankan sementara GPT-4-8K dan GPT-3.5-turbo mendukung 8.000 dan 4.000 token, masing-masing. Namun, perlu diingat bahwa setiap interaksi dengan model ini datang dengan biaya yang secara langsung proporsional dengan jumlah token yang diproses, baik input maupun output.
Dalam konteks sistem pertanyaan dan jawaban kita, jika sebuah literatur akademis melebihi batas token maksimum, sistem akan gagal memprosesnya secara keseluruhan, sehingga mempengaruhi kualitas dan kelengkapan respons. Untuk mengatasi masalah ini, teks dapat dipecah menjadi bagian yang lebih kecil yang sesuai dengan batas token.
FAISS (Facebook AI Similarity Search) (META ) membantu menemukan potongan teks yang paling relevan dengan pertanyaan pengguna dengan cepat. Ini membuat representasi vektor dari setiap potongan teks dan menggunakan vektor-vektor ini untuk mengidentifikasi dan mengambil potongan yang paling mirip dengan representasi vektor dari pertanyaan yang diberikan.
Penting untuk diingat bahwa bahkan dengan menggunakan alat seperti FAISS, kebutuhan untuk membagi teks menjadi potongan yang lebih kecil karena keterbatasan token dapat terkadang menyebabkan kehilangan konteks, mempengaruhi kualitas jawaban. Oleh karena itu, manajemen dan optimasi token yang cermat sangat penting ketika bekerja dengan model bahasa besar ini.
pip install faiss-cpu langchain CharacterTextSplitter
Setelah memastikan pustaka perangkat lunak di atas terinstal, jalankan
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documents = get_arxiv_data(max_results=10) # We can now use feed more data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
for chunk in splitter.split_text(document.page_content):
document_chunks.append(Document(page_content=chunk, metadata=document.metadata))
search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())
chain = load_qa_with_sources_chain(OpenAI(temperature=0))
def print_answer(question):
print(
chain(
{
"input_documents": search_index.similarity_search(question, k=4),
"question": question,
},
return_only_outputs=True,
)["output_text"]
)
Dengan kode selesai, kita sekarang memiliki alat yang kuat untuk mengajukan pertanyaan tentang literatur akademis terbaru di bidang NLP.
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1
Kesimpulan
Integrasi Model Bahasa Besar (LLM) ke dalam aplikasi telah mempercepat adopsi di berbagai domain, termasuk terjemahan bahasa, analisis sentimen, dan pengambilan informasi. Teknik prompt engineering adalah alat kuat dalam memaksimalkan potensi model ini, dan Langchain memimpin jalan dalam menyederhanakan tugas kompleks ini. Antarmuka standar, template prompt yang fleksibel, integrasi model yang kuat, dan penggunaan inovatif agen dan rantai memastikan hasil optimal untuk kinerja LLM.
Namun, meskipun kemajuan ini, ada beberapa tips yang perlu diingat. Ketika menggunakan Langchain, penting untuk memahami bahwa kualitas output sangat bergantung pada frasa prompt. Bereksperimen dengan gaya dan struktur prompt yang berbeda dapat menghasilkan hasil yang lebih baik. Juga, ingat bahwa Langchain mendukung berbagai model bahasa, dan setiap model memiliki kekuatan dan kelemahan. Memilih model yang tepat untuk tugas spesifik sangat penting. Terakhir, penting untuk diingat bahwa menggunakan model ini datang dengan pertimbangan biaya, karena pemrosesan token secara langsung mempengaruhi biaya interaksi.
Sebagaimana ditunjukkan dalam panduan langkah demi langkah, Langchain dapat memberdayakan aplikasi yang kuat, seperti Sistem Pertanyaan dan Jawaban Literatur Akademis. Dengan komunitas pengguna yang tumbuh dan meningkatnya kepentingan dalam lanskap sumber terbuka, Langchain berjanji untuk menjadi alat penting dalam mengoptimalkan potensi penuh dari LLM seperti GPT-4.














