Membangun Agen LangChain untuk Mengotomatiskan Tugas di Python

Penyiapan

Sebelum masuk lebih jauh, mari siapkan lingkungan untuk tutorial ini.

Pertama, buat environment Conda baru:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Menginstal paket LangChain dan beberapa pustaka penting lainnya:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Menambahkan environment Conda yang baru dibuat ke Jupyter sebagai kernel:

$ ipython kernel install --user --name=langchain

Membuat file .env untuk menyimpan secret seperti kunci API:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Mengambil kunci API OpenAI Anda dari file .env:

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

Menguji bahwa semuanya bekerja dengan benar dengan mengajukan pertanyaan ke GPT-3.5 (model bahasa default) dari OpenAI:

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

Sekarang, kita siap untuk memulai.

Apa itu Agen LangChain?

Mari luangkan waktu untuk memikirkan kerangka kerja agen. Secara khusus, kita akan melihat perbedaannya dari paradigma chain tradisional dan apa saja komponen dari sebuah agen. Memahami mengapa kita perlu memilih cara baru dalam membangun aplikasi akan mempersiapkan kita untuk menulis kodenya.

Chain vs. Agen

Ciri pembeda agen adalah kemampuannya memilih urutan tindakan terbaik untuk menyelesaikan masalah dengan serangkaian alat yang tersedia.

Misalnya, katakanlah kita memiliki hal-hal berikut:

• API cuaca
• Model ML untuk rekomendasi pakaian
• API Strava untuk rute bersepeda
• Basis data preferensi pengguna
• Model pengenalan gambar
• Model bahasa (generasi teks)

Pemecahan masalah tradisional akan melibatkan penggunaan chain dari alat-alat terpilih dari daftar tersebut:

Chain 1: Rekomendasi pakaian berbasis cuaca

1. Memanggil API cuaca
2. Memasukkan data cuaca ke model pakaian ML
3. Menghasilkan rekomendasi pakaian
4. Menyajikan hasil kepada pengguna

Chain 2: Penyaran rute bersepeda berbasis cuaca

1. Memanggil API cuaca
2. Memanggil API Strava untuk rute populer
3. Menyaring rute berdasarkan kondisi cuaca
4. Menyajikan rute yang sesuai kepada pengguna

Chain 3: Penganalisis foto pakaian

1. Menerima foto pakaian pengguna
2. Menggunakan model pengenalan gambar untuk mengidentifikasi item pakaian
3. Membandingkan dengan basis data preferensi pengguna
4. Menghasilkan umpan balik menggunakan model generasi teks
5. Menyajikan analisis kepada pengguna

Setiap chain menyelesaikan masalah tertentu menggunakan urutan langkah yang telah ditentukan dan subset alat yang tersedia. Mereka tidak dapat beradaptasi di luar cakupan yang telah didefinisikan. Mereka juga memerlukan tiga cabang pengembangan terpisah, yang tidak efisien dari segi waktu dan sumber daya.

Sekarang, bayangkan sistem agentic yang memiliki akses ke semua alat ini. Ia akan mampu:

1. Memahami pertanyaan atau masalah pengguna (melalui bahasa alami dengan model bahasa)
2. Menilai alat mana yang relevan dengan masalah (penalaran)
3. Menyusun alur kerja secara dinamis menggunakan alat yang paling tepat
4. Menjalankan alur kerja, melakukan penyesuaian waktu nyata bila diperlukan (bertindak)
5. Mengevaluasi hasil dan belajar dari interaksi sebelumnya

Contohnya, jika pengguna bertanya, “Apa yang harus saya pakai untuk bersepeda hari ini?” agen mungkin memeriksa API cuaca, menganalisis rute bersepeda yang cocok melalui Strava, merekomendasikan pakaian yang sesuai dengan mempertimbangkan preferensi pengguna sebelumnya, dan menghasilkan respons yang dipersonalisasi.

Agen dapat:

• Menangani beragam masalah menggunakan satu set alat yang sama
• Membuat alur kerja khusus untuk setiap situasi unik
• Menyesuaikan pendekatan berdasarkan konteks dan kebutuhan pengguna
• Belajar dari interaksi untuk meningkatkan kinerja di masa depan

Kemampuan LangChain untuk mentransformasikan model bahasa—yang pada dasarnya hanya menghasilkan teks—menjadi mesin penalaran yang dapat menggunakan sumber daya yang tersedia untuk mengambil tindakan yang tepat adalah salah satu penerapannya yang utama. Singkatnya, LangChain memungkinkan pengembangan agen otonom yang kuat yang berinteraksi dengan dunia luar.

Komponen kunci

Sebuah agen LangChain terdiri dari beberapa komponen, seperti model chat, template prompt, alat eksternal, dan konstruk terkait lain. Untuk membangun agen yang sukses, kita perlu meninjau setiap komponen dan memahami penggunaannya.

Model bahasa dan chat

Ada banyak bagian yang bergerak dalam membuat agen LangChain. Yang pertama dan paling jelas adalah model bahasa.

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

Model bahasa, seperti GPT-3.5 Turbo dari OpenAI, menerima dan menghasilkan string. Mereka biasanya lebih lama hadir dan paling baik untuk menjawab pertanyaan individual pengguna.

Model yang lebih baru dan lebih kuat biasanya adalah model chat, yang dapat menerima rangkaian pesan sebagai input dan mengembalikan pesan chat sebagai output (alih-alih menggunakan teks biasa):

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)

Dengan kata lain, model chat memungkinkan kita melakukan percakapan dalam bahasa alami. Pada contoh di atas, kita menginisialisasi GPT-4o-mini dengan pesan sistem yang diikuti pertanyaan pengguna. Perhatikan penggunaan kelas SystemMessage dan HumanMessage.

Objek output adalah sebuah message, yang merupakan perilaku yang diharapkan dari model chat:

type(output)

langchain_core.messages.ai.AIMessage

print(output.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!

Selain itu, mereka mengembalikan metadata berguna lain yang dapat diakses dengan dot-notation:

output.dict()

{'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}}

Kebanyakan agen menggunakan model chat karena basis pengetahuan yang diperbarui dan kapabilitas percakapannya. Namun, untuk agen sederhana tanpa kebutuhan memori, model bahasa seperti GPT-3.5 sudah memadai.

Template prompt

Cara paling efisien untuk mengajukan pertanyaan ke model bahasa atau chat adalah menggunakan template prompt. Ini memungkinkan Anda menyusun pertanyaan secara konsisten dan menyisipkan variabel secara dinamis, membuat interaksi dengan model menjadi lebih fleksibel dan dapat digunakan ulang.

Di LangChain, ada banyak jenis template prompt, dengan yang paling dasar adalah kelas PromptTemplate. Kelas ini dapat digunakan dengan model bahasa (teks polos):

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"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

Kelas ini mengharuskan Anda membuat string dengan placeholder untuk variabel yang ingin Anda ganti menggunakan notasi kurung. Lalu, Anda harus meneruskan string template ini ke kelas PromptTemplate beserta nama variabel, sehingga membentuk prompt Anda.

Memanggil .invoke() dengan nilai untuk variabel akan menunjukkan bagaimana prompt Anda akan diteruskan ke model.

Meneruskan template prompt ini ke model bahasa mengharuskan kita merantaikannya menggunakan operator pipa:

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])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

Operator pipa (|) adalah bagian dari LangChain Expression Language (LCEL), yang dirancang untuk merantai banyak komponen dan alat LangChain.

type(chain)

langchain_core.runnables.base.RunnableSequence

Saat Anda menggunakan operator pipa pada objek LangChain, Anda membuat instance kelas RunnableSequence. Runnable sequence merepresentasikan chain dari objek yang mendukung metode .invoke(), seperti template prompt dan model bahasa/chat.

Sekarang, mari lihat kelas template prompt lain untuk model chat:

from langchain_core.prompts import ChatPromptTemplate

Kita sebutkan bahwa model chat memerlukan rangkaian pesan sebagai input. Input awal biasanya adalah prompt sistem yang memberi tahu model chat bagaimana berperilaku. Jadi, menggunakan kelas ChatPromptTemplate, kita dapat dengan mudah membuat model chat dengan kepribadian berbeda:

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

Kelas ini memerlukan daftar pesan berbasis peran sebagai input. Setiap anggota daftar harus berupa tuple (role, message) dengan placeholder variabel didefinisikan sesuai kebutuhan.

Setelah siap, kita dapat menggunakan operator pipa yang sama untuk membuat model chat dengan perilaku berbeda:

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Alat

Pada bagian sebelumnya, kita menyebutkan bahwa agen dapat memilih kombinasi alat yang tersedia untuk menyelesaikan masalah tertentu, dengan LLM sebagai mesin penalaran di baliknya.

LangChain menawarkan integrasi dengan puluhan API dan layanan populer untuk memungkinkan agen berinteraksi dengan dunia luar. Sebagian besar tersedia di dalam paket langchain_community, sementara sebagian ada di dalam langchain_core.

Sebagai contoh, berikut cara menggunakan alat ArXiv untuk mengambil ringkasan makalah pada berbagai topik:

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

Ada cara alternatif untuk memuat alat alih-alih mengimpornya berdasarkan nama kelasnya:

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Di atas, kita memuat alat arXiv dan generator gambar Dall-E sekaligus menggunakan fungsi load_tools(). Alat yang dimuat dengan fungsi ini memiliki sintaks penggunaan yang sama:

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

Fungsi load_tools mengharuskan Anda mengetahui nama string kelas alat, seperti contoh ArxivQueryRun versus 'arxiv'. Anda dapat dengan cepat memeriksa nama string alat apa pun dengan menjalankan fungsi get_all_tool_names:

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
'searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

Perlu dicatat bahwa load_tools() hanyalah fungsi singkat. Saat membangun agen, disarankan memuat alat menggunakan konstruktor kelasnya, yang memungkinkan Anda mengonfigurasinya sesuai perilaku spesifiknya.

Alur Kerja Langkah demi Langkah Cara Membangun Agen LangChain

Akhirnya, pada bagian ini, kita akan melihat cara membuat agen LangChain langkah demi langkah menggunakan pengetahuan yang telah kita peroleh pada bagian-bagian sebelumnya.

Dalam contoh berikut, kita akan membangun agen yang mampu menjelaskan topik apa pun melalui tiga medium: teks, gambar, atau video. Lebih spesifiknya, berdasarkan pertanyaan yang diajukan, agen akan memutuskan format apa yang digunakan untuk menjelaskan topik.

Mari mulai. Ingat untuk melihat cara menyiapkan environment, yang dibahas di awal artikel. 

1. Mendefinisikan alat

Langkah pertama setelah mengonfigurasi environment adalah mendefinisikan alat yang akan kita berikan ke agen. Mari impor alat-alatnya:

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Kita mengimpor lima kelas:

• WikipediaAPIWrapper: untuk mengonfigurasi cara mengakses API Wikipedia
• WikipediaQueryRun: untuk menghasilkan ringkasan halaman Wikipedia
• YouTubeSearchTool: untuk mencari video YouTube tentang topik tertentu
• DallEAPIWrapper: untuk mengonfigurasi cara mengakses endpoint DallE milik OpenAI
• OpenAIDALLEImageGenerationTool: untuk menghasilkan gambar menggunakan prompt

Saat pengguna mengajukan pertanyaan ke agen, agen akan memutuskan apakah akan menjelaskan topik menggunakan artikel Wikipedia dalam format teks, atau dengan membuat gambar menggunakan Dall-E untuk pemahaman visual, atau dengan menyarankan video YouTube untuk pemahaman yang lebih mendalam.

Mari inisialisasi alat-alat tersebut, mulai dari alat Wikipedia:

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

Generator gambar DallE:

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

Alat pencarian YouTube:

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Perhatikan deskripsi alat dengan saksama. Agen akan memutuskan alat mana yang digunakan berdasarkan deskripsi yang Anda berikan. 

Sekarang, kita akan memasukkan alat-alat tersebut ke dalam sebuah daftar:

tools = [wikipedia, dalle, youtube]

Kita sudah bisa mengikat kumpulan alat ini ke model chat tanpa membuat agen:

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Mari coba memanggil model dengan pesan sederhana:

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

Output menunjukkan bahwa tidak ada alat terikat yang digunakan saat menghasilkan jawaban. Sekarang, mari ajukan pertanyaan spesifik yang memaksa model untuk melihat di luar data pelatihannya:

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

Kita melihat tidak ada output teks, tetapi DallE milik OpenAI disebutkan. Alat belum dipanggil; model hanya menyarankan untuk menggunakannya. Untuk benar-benar memanggilnya—untuk bertindak, kita perlu membuat agen.

2. Membuat agen sederhana

Setelah mendefinisikan model dan alat, kita membuat agen. LangChain menawarkan antarmuka fungsi tingkat tinggi create_react_agent() dari paket langgraph untuk cepat membuat agen ReAct (reason and act):

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Saat menginisialisasi agen dengan model chat dan daftar alat, kita menyertakan prompt sistem untuk memberi tahu model bagaimana berperilaku secara umum. Sekarang siap menerima pertanyaan:

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

Kita menerima respons yang masuk akal, yaitu jawaban teks sederhana tanpa panggilan alat. Sekarang, mari bertanya sesuatu yang lebih spesifik:

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Kali ini, ada empat pesan. Mari lihat nama kelas pesan dan isinya:

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

Nah, ini dia! Pesan ketiga berasal dari panggilan alat, yaitu ringkasan halaman Wikipedia tentang fotosintesis. Pesan terakhir berasal dari model chat, yang menggunakan isi panggilan alat saat menyusun jawabannya.

Mari cepat buat fungsi untuk memodularisasi langkah-langkah terakhir yang kita lakukan:

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Memperbaiki prompt sistem

Sekarang, mari perbarui prompt sistem kita dengan instruksi terperinci tentang bagaimana agen harus berperilaku:

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Mari buat ulang agen kita dengan prompt sistem baru:

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Keren, berdasarkan pesan kita (yang sangat mengarahkan :), agen memilih alat yang tepat untuk tugasnya. Berikut gambar yang dihasilkan:

4. Menambahkan memori ke agen

Saat ini, agen kita bersifat stateless, yang berarti tidak mengingat interaksi sebelumnya:

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

Cara termudah untuk menambahkan riwayat pesan chat ke agen adalah menggunakan kelas langgraph, yaitu SqliteSaver:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

Kita menginisialisasi memori menggunakan metode .from_conn_string() dari kelas SqliteSaver, yang membuat file basis data. Lalu, kita meneruskan memory ke parameter checkpointer dari fungsi create_react_agent().

Sekarang, kita perlu membuat kamus konfigurasi:

config = {'configurable': {'thread_id': 'a1b2c3'}}

Kamus ini mendefinisikan ID thread untuk membedakan satu percakapan dari lainnya dan diteruskan ke metode .invoke() dari agen kita. Jadi, mari perbarui fungsi execute() untuk menyertakan perilaku ini:

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Sekarang, mari tanya agen tentang pertanyaan sebelumnya:

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Sesuai harapan, agen mengembalikan pesan-pesan sebelumnya! Sekarang, kita hanya butuh UI chat seperti ChatGPT dan kita sudah punya chatbot kustom.

Tren dan Perkembangan Mendatang

Sepanjang artikel, kita melihat sekilas arah LangChain dalam hal agen. Hingga baru-baru ini, LangChain terutama menggunakan kelas AgentExecutor namun perlahan digantikan oleh agen langgraph.

Agen LangChain murni bagus untuk mulai belajar, tetapi memerlukan lebih banyak baris kode untuk membangun agen yang sama daripada di LangGraph. Selain itu, setelah titik tertentu, kerangka kerja AgentExecutor tidak akan menyediakan fleksibilitas yang dimiliki LangGraph untuk membangun agen multi-alat yang kompleks.

Itulah mengapa sekarang waktu yang tepat untuk mengikuti gelombang dan mulai langsung dengan LangGraph.

Kami sangat merekomendasikan untuk mulai menggunakan LangSmith juga, yang telah menjadi bagian inti dari ekosistem LangChain untuk membangun aplikasi LLM siap produksi. Berikut beberapa manfaat utamanya:

• Debugging: LangSmith menyediakan jejak terperinci eksekusi agen Anda, sehingga lebih mudah mengidentifikasi dan memperbaiki masalah.
• Optimasi Kinerja: Dengan LangSmith, Anda dapat menganalisis penggunaan token, latensi, dan metrik kinerja lainnya untuk mengoptimalkan efisiensi agen Anda.
• Pengujian dan Evaluasi: LangSmith memfasilitasi pembuatan dan pengelolaan dataset uji, memungkinkan Anda mengevaluasi performa agen secara ketat di berbagai skenario.
• Pemantauan: Di lingkungan produksi, LangSmith menawarkan kapabilitas pemantauan waktu nyata, memungkinkan Anda melacak kinerja agen dan mendeteksi anomali dengan cepat.

Berikut cara memulai dengan LangSmith:

1. Daftar akun gratis di sini.
2. Setel variabel lingkungan.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

dan Anda siap! Saat Anda mulai melakukan kueri ke model bahasa/chat, LangSmith mulai mencatat berbagai metrik tentang setiap run:

Kesimpulan

Dalam artikel ini, kita membahas apa yang membuat agen LangChain berbeda dari chain dan blok bangunan penting yang digunakan untuk menyusunnya. Pertama, kami memperkenalkan apa itu agen dan bagaimana perbedaannya dari konstruk chain yang lebih tradisional terkait fleksibilitas dan kapabilitas dalam mengambil keputusan.

Kemudian kita melihat komponen kunci yang perlu Anda ketahui untuk membangun agen: model chat, alat, dan template prompt. Terakhir, kita menelusuri dua contoh yang memperlihatkan cara membangun agen sederhana dan lanjutan. Pemrosesan bahasa alami terus berkembang, dan agen LangChain berada di garis depan perkembangan ini, membuka jalan bagi keluarga AI yang lebih cerdas dan serbaguna.

Berikut beberapa sumber terkait untuk meningkatkan kemampuan LangChain Anda:

• Kursus Mengembangkan Aplikasi LLM dengan LangChain 
• Pengantar Prompt Engineering dengan LangChain 
• Tutorial Cara Membangun Aplikasi LLM dengan LangChain
• Membangun Model GPT dengan Kapabilitas Browsing Menggunakan Alat LangChain
• LangChain vs LlamaIndex: Perbandingan Mendalam

Terima kasih telah membaca!