Ide inti dari LangChain Agent adalah menggunakan LLM sebagai otak untuk berpikir secara otomatis, membuat keputusan, dan menjalankan berbagai tindakan untuk akhirnya menyelesaikan tugas target kita.

Tip: Dari perspektif pengembangan, ini berarti kita mengembangkan berbagai API terlebih dahulu dan kemudian memberikan tugas kepada Agen, memungkinkan LLM untuk menganalisis API mana yang harus dipanggil untuk menyelesaikan tugas.

Untuk lebih memahami masalah yang ingin diselesaikan oleh LangChain Agent, mari pertimbangkan contoh berikut.

Contohnya:

Jika kita ingin meneliti apakah "Docker dapat digunakan sebagai solusi implementasi produksi," kita akan mulai dengan mencari "pengenalan Docker" di Baidu, menjelajahi hasil pencarian, dan kemudian mencari "kelebihan dan kekurangan implementasi Docker" dan menjelajahi hasilnya, dan seterusnya, hingga mencapai kesimpulan.

LangChain Agent bertujuan untuk mensimulasikan proses ini. Saya dapat memaketkan sejumlah alat (misalnya, pencarian Baidu, alat ekstraksi konten URL), dan kemudian memberikan tugas kepada Agen "Apakah Docker dapat digunakan sebagai solusi implementasi produksi?" Agen akan kemudian membangun prompt untuk memanggil LLM. Untuk mencapai tugas ini, langkah selanjutnya adalah melakukan tindakan apa (yaitu, memanggil alat mana). Kecerdasan buatan akan memberikan alat yang harus dipanggil, kode akan menjalankan alat ini, kemudian meneruskan hasil dari eksekusi alat kembali ke kecerdasan buatan, dan bertanya untuk langkah selanjutnya dalam menjalankan alat mana. Mengulangi proses ini akan menyelesaikan tugas yang disebutkan sebelumnya.

Tip: Sejak rilis model GPT, ini adalah kapabilitas yang luar biasa, memungkinkan LLM bertindak sebagai otak, berpikir secara aktif, dan kemudian memanggil berbagai API yang telah kami kembangkan. Ini meningkatkan kemampuan LLM secara signifikan. Saat ini, fitur ini masih dalam tahap eksperimental dan akan secara berulang memanggil LLM, sehingga mengonsumsi banyak token. Menyelesaikan tugas dapat menghabiskan puluhan ribu token dalam hitungan menit. Jika Anda ingin menghemat uang, disarankan untuk pertama-tama membiarkan LLM melakukan tugas-tugas penilaian logis yang sederhana.

Konsep Inti

Mari kita sekarang memperkenalkan komponen & konsep terkait.

Agen

Seorang Agen dapat dipahami sebagai asisten kita, bertindak atas nama kita untuk membuat keputusan. Dalam implementasi mendasar LangChain Agent, melalui LLM bahwa langkah berikutnya (atau panggilan API) ditentukan. Mode ReAct menggambarkan proses pengambilan keputusan kecerdasan buatan. Mereka yang tertarik dapat menjelajahi lebih lanjut.

LangChain menyediakan beberapa jenis Agen untuk skenario yang berbeda.

Alat

Saya pikir Alat lebih baik dipahami sebagai API, yang telah dikemas sebelumnya dengan berbagai API fungsional yang dirancang untuk memperluas kemampuan LLM. LLM menentukan API spesifik mana yang akan dipanggil untuk menyelesaikan tugas.

Paket Alat

Paket Alat biasanya memberikan LLM bukan hanya satu atau dua alat, tetapi sekelompok alat untuk memberikan LLM lebih banyak pilihan saat menyelesaikan tugas.

AgentExecutor

Eksekutor proxy bertanggung jawab untuk mengeksekusi alat (API) yang dipilih oleh LLM. Kode palsu untuk runtime ini adalah sebagai berikut:

next_action = agent.get_action(...)
while next_action != AgentFinish:
    observation = run(next_action)
    next_action = agent.get_action(..., next_action, observation)
return next_action

Meskipun proses eksekusi tidak rumit, eksekutor menangani banyak masalah detail, terutama termasuk:

  1. Menangani situasi di mana agen memilih alat yang tidak ada
  2. Menangani situasi kesalahan alat
  3. Menangani situasi di mana agen menghasilkan output yang tidak dapat diselesaikan sebagai panggilan alat
  4. Masalah debugging.

Memulai Cepat

Bagian ini memperkenalkan penggunaan dasar dari Agen LangChain.

1. Memuat LLM

Pertama, mari kita muat model bahasa (LLM) yang akan kita gunakan untuk mengendalikan agen.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

2. Mendefinisikan Alat

Selanjutnya, kita mendefinisikan beberapa alat yang dapat dipanggil oleh Agen. Kita akan menulis fungsi Python yang sangat sederhana untuk menghitung panjang kata input.

from langchain.agents import tool

@tool
def get_word_length(word: str) -> int:
    """Mengembalikan panjang kata."""
    return len(word)

get_word_length.invoke("abc")

Catatan: Komentar fungsi sangat penting. Mereka memberitahu LLM masalah apa yang dapat diselesaikannya dengan memanggil mereka. Fungsi get_word_length memberitahu LLM bahwa ia dapat menghitung panjang suatu kata.

3

Tentukan sejumlah alat

tools = [get_word_length]

3. Membuat Permintaan

Sekarang mari kita buat sebuah permintaan. Karena OpenAI Function Calling telah dioptimalkan untuk penggunaan alat, kita hampir tidak memerlukan instruksi tentang penalaran atau format output. Kita hanya memiliki dua variabel masukan: input dan agent_scratchpad. input mewakili pertanyaan masukan pengguna, dan agent_scratchpad adalah placeholder untuk instruksi panggilan agen, yang akan dimasukkan ke dalam templat permintaan saat menjalankan perintah panggilan alat.

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "Anda adalah asisten yang sangat hebat tetapi tidak memahami situasi saat ini.",
        ),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

4. Memasangkan Alat ke LLM

Bagaimana agen mengetahui alat-alat apa yang dapat digunakannya?

Hal ini bergantung pada fitur panggilan alat OpenAI (banyak model mendukung fitur serupa). Kita hanya perlu memberitahu model format panggilan alat yang telah ditentukan.

llm_with_tools = llm.bind_tools(tools)

5. Membuat Agen

Sekarang setelah kita telah mengintegrasikan konten sebelumnya, kita dapat melanjutkan untuk membuat program pengganti. Kita akan mengimpor dua fungsi utilitas praktis terakhir: satu untuk memformat langkah-langkah perantara (tindakan pengganti, output alat) ke pesan masukan yang dapat dikirim ke model, dan yang lainnya untuk mengonversi pesan keluaran menjadi tindakan pengganti/akhir pengganti.

from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]),
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

Pengaturan eksekutor agen

from langchain.agents import AgentExecutor

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Mari kita tunjukkan operasi program pengganti melalui contoh:

list(agent_executor.stream({"input": "Berapa huruf dalam kata 'eudca'?"}))

Contoh log keluaran agen

> Memasuki rantai eksekusi agen baru...

Pemanggilan: Menjalankan `get_word_length` dengan parameter `{'word': 'educa'}`

Ada 5 huruf dalam kata "educa".

> Rantai eksekusi selesai.

Melalui contoh ini, kami telah menunjukkan proses lengkap dari program pengganti.

Menambahkan Fungsi Memori ke Agen

Jika kita ingin agen mengingat percakapan sebelumnya, sebenarnya cukup sederhana: kita hanya perlu memasukkan konten yang dikembalikan oleh AI ke dalam permintaan dan mengirimkannya ke AI secara bersamaan.

Memodifikasi templat permintaan

Di bawah ini kita modifikasi templat permintaan untuk menyertakan variabel templat riwayat percakapan.

from langchain.prompts import MessagesPlaceholder

MEMORY_KEY = "chat_history"
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "Anda adalah asisten yang hebat, tetapi tidak mahir dalam menghitung panjang kata.",
        ),
        MessagesPlaceholder(variable_name=MEMORY_KEY),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

Memodifikasi definisi proses agen

Modifikasi definisi proses agen untuk memberikan data riwayat percakapan ke templat permintaan, seperti yang ditunjukkan dalam kode berikut, menambahkan penanganan parameter chat_history.

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(
            x["intermediate_steps"]
        ),
        "chat_history": lambda x: x["chat_history"],
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Menyediakan data riwayat percakapan saat memanggil agen

riwayat_percakapan = []

input1 = "Berapa banyak huruf yang ada dalam kata 'educa'?"
hasil = executor_agen.memanggil({"input": input1, "riwayat_percakapan": riwayat_percakapan})
riwayat_percakapan.extend(
    [
        PesanManusia(isi=input1),
        PesanAI(isi=hasil["keluaran"]),
    ]
)
executor_agen.memanggil({"input": "Apakah kata ini benar-benar ada?", "riwayat_percakapan": riwayat_percakapan})

Dalam skenario bisnis sebenarnya, Anda dapat menyimpan riwayat percakapan ke dalam database dan memasukkan data ke dalam prompt sesuai dengan kebutuhan bisnis.

Tip: Fungsi memori dari model besar (LLM) saat ini sebagian besar dicapai dengan memasukkan konten percakapan historis ke dalam prompt dan mengirimkannya ke LLM. LangChain hanya memberikan beberapa enkapsulasi. Anda dapat memilih untuk tidak menggunakannya dan secara manual menggabungkan riwayat percakapan ke dalam templat prompt.