Setiap rantaian menyelesaikan masalah tertentu menggunakan urutan langkah yang telah ditetapkan dan subset alat yang tersedia. Mereka tidak boleh menyesuaikan diri di luar skop mereka yang ditakrifkan. Mereka juga memerlukan tiga cabang pembangunan yang berasingan, yang tidak cekap dari segi masa dan sumber.
Sekarang, bayangkan sistem agentik dengan akses kepada semua alat ini. Ia akan dapat:
Ejen boleh:
mengendalikan pelbagai masalah menggunakan set alat yang sama
- Buat aliran kerja tersuai untuk setiap situasi yang unik
- menyesuaikan pendekatannya berdasarkan konteks tertentu dan keperluan pengguna
- belajar dari interaksi untuk meningkatkan prestasi masa depan
-
keupayaan Langchain untuk mengubah model bahasa - yang, dengan sendirinya, hanya menghasilkan teks - ke dalam enjin penalaran yang boleh menggunakan sumber yang mereka gunakan untuk mengambil tindakan yang sesuai adalah salah satu aplikasi utamanya. Singkatnya, Langchain membolehkan pembangunan agen autonomi yang kuat yang berinteraksi dengan dunia luar.
Komponen utama
Ejen Langchain terdiri daripada beberapa komponen, seperti model sembang, templat segera, alat luaran, dan pembinaan lain yang berkaitan. Untuk membina ejen yang berjaya, kita perlu mengkaji semula setiap komponen dan memahami penggunaannya.
model bahasa dan sembang
Terdapat banyak bahagian bergerak yang terlibat dalam mewujudkan ejen Langchain. Yang pertama dan paling jelas adalah model bahasa.
$ conda create -n langchain python=3.9 -y
$ conda activate langchain
Model bahasa, seperti Openai's GPT-3.5 Turbo, mengambil dan menjana rentetan. Mereka biasanya lebih tua dan berfungsi dengan baik untuk menjawab pertanyaan pengguna individu. $ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv
model yang lebih baru dan lebih berkuasa biasanya model sembang, yang boleh mengambil urutan mesej sebagai input dan mengembalikan mesej sembang sebagai output (berbanding menggunakan teks biasa):
$ conda create -n langchain python=3.9 -y
$ conda activate langchain
Masukkan secara berbeza, model sembang membolehkan kita mengadakan perbualan dalam bahasa semula jadi. Dalam contoh di atas, kami memulakan GPT-4O-Mini dengan mesej sistem yang diikuti oleh pertanyaan pengguna. Perhatikan penggunaan kelas SystemMessage dan HumanMessage.
output adalah objek mesej, yang merupakan tingkah laku yang diharapkan dari model sembang:
$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv
$ ipython kernel install --user --name=langchain
$ touch .env
$ vim .env # Paste your OPENAI key
OPENAI_API_KEY='YOUR_KEY_HERE'
Selain itu, mereka mengembalikan metadata berguna lain yang boleh diakses dengan dot-notasi:
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')
from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])
Kebanyakan ejen menggunakan model sembang kerana asas pengetahuan yang dikemas kini dan keupayaan perbualan. Walau bagaimanapun, untuk ejen mudah tanpa keperluan memori, model bahasa seperti GPT-3.5 akan mencukupi.
templat prompt
Cara yang paling berkesan untuk menanyakan bahasa atau model sembang adalah dengan menggunakan templat segera. Mereka membolehkan anda menyusun pertanyaan anda secara konsisten dan memasukkan pembolehubah secara dinamik, menjadikan interaksi anda dengan model yang lebih fleksibel dan boleh diguna semula.
Di Langchain, terdapat banyak jenis templat segera, dengan yang paling asas ialah kelas prompttemplate. Ia boleh digunakan dengan model bahasa (teks biasa):
There is no definitive answer to this question, as it is subjective and de
from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])
Kelas memerlukan anda membuat rentetan dengan ruang letak untuk pembolehubah yang anda ingin ganti menggunakan notasi kurungan. Kemudian, anda perlu lulus rentetan templat ini ke kelas prompttemplate bersama -sama dengan nama -nama pembolehubah, dengan itu membina prompt anda.
memanggil .Invoke () dengan nilai untuk pembolehubah akan menunjukkan bagaimana petikan anda akan dihantar ke model.
Lulus template cepat ini ke model bahasa memerlukan kita untuk mengikatnya menggunakan pengendali paip:
1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)
Pengendali paip (|) adalah sebahagian daripada bahasa ekspresi Langchain (LCEL), yang direka untuk mengikat pelbagai komponen dan alat Langchain.
type(output)
langchain_core.messages.ai.AIMessage
Apabila anda menggunakan pengendali paip pada objek Langchain, anda membuat contoh kelas Runnablequence. Urutan runnable mewakili rangkaian objek yang menyokong kaedah .Invoke (), seperti template prompt dan model bahasa/sembang.
Sekarang, mari kita lihat kelas template yang lain untuk model sembang:
print(output.content)
Kami menyebut bahawa model sembang memerlukan urutan mesej sebagai input. Input awal biasanya merupakan sistem yang memberitahu model sembang bagaimana untuk berkelakuan. Oleh itu, menggunakan kelas ChatPromptTemplate, kita boleh membuat model sembang dengan personaliti yang berbeza:
Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!
Kelas memerlukan senarai mesej berasaskan peranan sebagai input. Setiap ahli senarai mestilah (peranan, mesej) tuple dengan tempat -tempat yang ditakrifkan di mana diperlukan.
Selepas kami bersiap sedia, kami boleh menggunakan pengendali paip yang sama untuk membuat model sembang dengan tingkah laku yang berbeza:
$ conda create -n langchain python=3.9 -y
$ conda activate langchain
$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv
Alat
Di bahagian sebelumnya, kami menyebut bahawa ejen boleh memilih gabungan alat yang mereka lakukan untuk menyelesaikan masalah tertentu, dengan LLM sebagai enjin penalaran di bawah tudung.
Langchain menawarkan integrasi dengan berpuluh -puluh API dan perkhidmatan yang popular untuk membiarkan ejen berinteraksi dengan seluruh dunia. Kebanyakan mereka boleh didapati di bawah pakej Langchain_Community, sementara ada di dalam langchain_core.
Sebagai contoh, inilah cara anda boleh menggunakan alat ARXIV untuk mendapatkan ringkasan kertas pada pelbagai topik:
$ ipython kernel install --user --name=langchain
$ touch .env
$ vim .env # Paste your OPENAI key
OPENAI_API_KEY='YOUR_KEY_HERE'
Terdapat cara alternatif untuk memuatkan alat dan bukannya mengimportnya dengan nama kelas mereka:
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')
di atas, kita memuatkan alat penjana imej ARXIV dan DALL-E pada masa yang sama menggunakan fungsi LOAD_TOOLS (). Alat yang dimuatkan dengan fungsi ini mempunyai sintaks penggunaan yang sama:
from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])
There is no definitive answer to this question, as it is subjective and de
from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])
1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make
Fungsi LOAD_TOOLS memerlukan anda mengetahui nama rentetan kelas alat, seperti contoh ArxivQueryrun berbanding 'arxiv'. Anda boleh dengan cepat menyemak nama rentetan mana -mana alat dengan menjalankan fungsi get_all_tool_names:
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)
type(output)
Perhatikan bahawa LOAD_TOOLS () hanya fungsi singkat. Apabila ejen bangunan, disyorkan untuk memuatkan alat menggunakan pembina kelas mereka, yang membolehkan anda mengkonfigurasi mereka berdasarkan tingkah laku khusus mereka.
aliran kerja langkah demi langkah bagaimana membina ejen langchain
Akhirnya, dalam bahagian ini, kita akan melihat bagaimana untuk membuat ejen Langchain langkah demi langkah menggunakan pengetahuan yang telah kami perolehi di bahagian sebelumnya.
Dalam contoh yang akan datang, kami akan membina ejen yang mampu menjelaskan topik melalui tiga medium: teks, imej, atau video. Lebih khusus, berdasarkan soalan yang ditanya, ejen akan memutuskan sama ada untuk menerangkan topik dalam format apa.
mari kita mulakan. Ingatlah untuk menyemak bagaimana untuk menubuhkan persekitaran, yang diliputi pada permulaan artikel.
1. Menentukan Alat
Langkah pertama selepas mengkonfigurasi persekitaran kita adalah menentukan alat yang akan kami berikan kepada ejen kami. Mari kita mengimport mereka:
langchain_core.messages.ai.AIMessage
Kami mengimport lima kelas:
WikipediaapiPiWrapper: Untuk mengkonfigurasi cara mengakses Wikipedia API -
wikipediaqueryrun: untuk menghasilkan ringkasan halaman wikipedia -
youtubesearchtool: untuk mencari video youtube mengenai topik -
dalleaPiWrapper: Untuk mengkonfigurasi cara mengakses titik akhir Dalle Openai -
openaidalleimageGenerationTool: untuk menghasilkan imej menggunakan prompt -
Apabila pengguna menanyakan ejen kami, ia akan memutuskan sama ada untuk menerangkan topik menggunakan artikel Wikipedia dalam format teks, atau dengan membuat imej menggunakan Dall-E untuk pemahaman visual, atau dengan mencadangkan video YouTube untuk pemahaman yang lebih mendalam.
mari kita mulakannya, bermula dengan alat Wikipedia:
$ conda create -n langchain python=3.9 -y
$ conda activate langchain
$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv
Generator Imej Dalle:
$ ipython kernel install --user --name=langchain
Alat carian YouTube:
$ touch .env
$ vim .env # Paste your OPENAI key
OPENAI_API_KEY='YOUR_KEY_HERE'
mengambil perhatian khusus mengenai deskripsi alat. Ejen akan memutuskan mana satu alat yang hendak digunakan berdasarkan keterangan yang anda berikan.
Sekarang, kami akan memasukkan alat ke dalam senarai:
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY') kita sudah dapat mengikat set alat ini ke model sembang tanpa membuat ejen:
from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])
Mari cuba memanggil model dengan mesej mudah:
There is no definitive answer to this question, as it is subjective and de
from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])
output menunjukkan bahawa tiada alat terikat yang digunakan apabila menghasilkan jawapan. Sekarang, mari kita tanya soalan khusus yang akan memaksa model untuk melihat di luar data latihannya:
1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
HumanMessage(content="What's up?")]
output = chat_model.invoke(messages) kita dapat melihat tiada output teks, tetapi Dalle Openai disebutkan. Alat ini belum dipanggil; Model ini hanya mencadangkan kita menggunakannya. Untuk benar -benar memanggilnya - untuk mengambil tindakan, kita perlu membuat ejen.
2. Membuat ejen mudah
Selepas menentukan model dan alat, kami membuat ejen. Langchain menawarkan antara muka fungsi create_react_agent () peringkat tinggi dari pakej Langgraphnya untuk membuat ejen React (Alasan dan ACT) dengan cepat:
type(output)
Semasa memulakan ejen dengan model sembang dan senarai alat, kami meluluskan sistem untuk memberitahu model bagaimana berkelakuan secara umum. Kini sudah bersedia untuk menerima pertanyaan:
langchain_core.messages.ai.AIMessage
print(output.content)
kami telah menerima tindak balas yang mungkin, yang merupakan jawapan teks mudah tanpa panggilan alat. Sekarang, mari kita tanya sesuatu yang lebih kepada titik:
Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!
output.dict()
Kali ini, terdapat empat mesej. Mari lihat nama kelas mesej dan kandungan mereka:
{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
'prompt_tokens': 21,
'total_tokens': 59},
'model_name': 'gpt-4o-mini-2024-07-18',
'system_fingerprint': 'fp_48196bc67a',
'finish_reason': 'stop',
'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
'output_tokens': 38,
'total_tokens': 59}}
from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"}) di sini kita pergi! Mesej ketiga adalah dari panggilan alat, yang merupakan ringkasan halaman Wikipedia pada fotosintesis. Mesej terakhir adalah dari model sembang, yang menggunakan kandungan panggilan alat ketika membina jawapannya.
Mari kita cepat buat fungsi untuk memodulasi langkah -langkah terakhir yang kami ambil:
StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')
3. Memperbaiki sistem prompt
Sekarang, mari kita mengemas kini sistem kami dengan arahan terperinci tentang bagaimana ejen harus berkelakuan:
from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100]) mari kita mencipta semula ejen kami dengan sistem baru:
Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R
type(chain)
Awesome, berdasarkan mesej kami (yang sangat mengajar :), ejen memilih alat yang betul untuk pekerjaan itu. Inilah gambar yang dihasilkan:
4. Menambah memori kepada ejen
Sekarang, ejen kami tidak beraksi, yang bermaksud ia tidak ingat interaksi sebelumnya:
$ conda create -n langchain python=3.9 -y
$ conda activate langchain
$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv
Cara paling mudah untuk menambah sejarah mesej sembang kepada ejen adalah dengan menggunakan kelas SQLitesaver Langgraph:
$ ipython kernel install --user --name=langchain
Kami memulakan memori menggunakan kaedah kelas SQLitesaver () yang mewujudkan fail pangkalan data. Kemudian, kami lulus memori ke parameter CheckPointer Create_React_agent () fungsi.
Sekarang, kita perlu membuat kamus konfigurasi:
$ touch .env
$ vim .env # Paste your OPENAI key
Kamus mentakrifkan ID benang untuk membezakan satu perbualan dari yang lain dan ia diserahkan kepada kaedah .Invoke () ejen kami. Oleh itu, mari kita mengemas kini fungsi Eksecute () kami untuk memasukkan tingkah laku ini:
OPENAI_API_KEY='YOUR_KEY_HERE'
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')
Sekarang, mari kita tanya ejen mengenai pertanyaan sebelumnya:
from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])
There is no definitive answer to this question, as it is subjective and de
Seperti yang dijangkakan, ejen itu mengembalikan mesej sebelumnya! Sekarang, kita hanya memerlukan UI sembang seperti chatgpt dan kita telah mendapat chatbot tersuai.
Trend dan Perkembangan Masa Depan
Sepanjang artikel, kami telah melihat sekilas di mana Langchain pergi dari segi ejen. Sehingga baru -baru ini, Langchain terutamanya menggunakan kelas AgentExecutor tetapi perlahan -lahan digantikan oleh agen Langgraph.
Ejen Langchain tulen adalah baik untuk bermula, tetapi mereka memerlukan lebih banyak baris kod untuk membina ejen yang sama daripada Langgraph. Juga, selepas satu titik tertentu, rangka kerja AgentExecutor tidak akan memberikan fleksibiliti LangGraph untuk membina agen pelbagai alat kompleks.
Itulah sebabnya sekarang adalah masa yang tepat untuk menunggang gelombang dan bermula dengan Langgraph secara langsung.
Kami sangat mengesyorkan untuk mula menggunakan Langsmith juga, yang telah menjadi bahagian teras ekosistem Langchain untuk membina aplikasi LLM gred pengeluaran. Berikut adalah beberapa faedah utamanya:
- Debugging: Langsmith menyediakan jejak terperinci pelaksanaan ejen anda, menjadikannya lebih mudah untuk mengenal pasti dan memperbaiki isu -isu.
- Pengoptimuman Prestasi: Dengan Langsmith, anda boleh menganalisis penggunaan token, latensi, dan metrik prestasi lain untuk mengoptimumkan kecekapan ejen anda.
- Ujian dan Penilaian: Langsmith memudahkan penciptaan dan pengurusan dataset ujian, membolehkan anda menilai prestasi ejen anda dengan ketat dalam pelbagai senario.
Pemantauan: Dalam persekitaran pengeluaran, Langsmith menawarkan keupayaan pemantauan masa nyata, membolehkan anda menjejaki prestasi ejen anda dan mengesan anomali dengan cepat. -
inilah cara anda boleh memulakan dengan Langsmith:
Daftar untuk akaun percuma di sini. -
Tetapkan pembolehubah persekitaran. -
Export langchain_tracing_v2 = "true"
Export langchain_api_key = "..."
dan anda baik untuk pergi! Semasa anda mula menanyakan model bahasa/sembang, Langsmith mula melayari pelbagai metrik mengenai setiap larian:
Kesimpulan
Dalam artikel ini, kami meneroka apa yang menjadikan agen Langchain berbeza dari rantai dan blok bangunan penting yang digunakan dalam membina mereka. Kami mula -mula memperkenalkan ejen apa dan bagaimana mereka berbeza dari pembinaan rantaian yang lebih tradisional mengenai fleksibiliti dan keupayaan dalam membuat keputusan.
Kemudian kami melihat komponen utama yang perlu anda ketahui untuk membina ejen: model sembang, alat, dan templat segera. Akhirnya, kami berlari melalui dua contoh yang menunjukkan cara membina ejen yang mudah dan maju. Pemprosesan bahasa semulajadi sedang berkembang secara berterusan, dan ejen Langchain berada di barisan hadapan perkembangan ini, membuka jalan bagi keluarga AI yang lebih pintar dan serba boleh.
Berikut adalah beberapa sumber yang berkaitan untuk meningkatkan langku anda:
Membangunkan aplikasi LLM dengan kursus Langchain -
Pengenalan kepada Kejuruteraan Prompt dengan Langchain -
bagaimana membina aplikasi LLM dengan tutorial langchain -
Membina model GPT dengan keupayaan melayari menggunakan alat Langchain -
Langchain vs llamaindex: Perbandingan terperinci -
terima kasih kerana membaca!
4. Menambah memori kepada ejen