Mengembangkan aplikasi

Contoh aplikasi kecil yang dapat Anda buat menggunakan LangChain pada Vertex AI adalah platform yang menampilkan nilai tukar antara dua mata uang pada tanggal tertentu.

Anda dapat menentukan class Python Anda sendiri (lihat Menyesuaikan template aplikasi), atau Anda dapat menggunakan class LangchainAgent di Vertex AI SDK untuk Python agen keamanan. Langkah-langkah berikut menunjukkan cara membuat aplikasi ini menggunakan LangchainAgent template bawaan:

  1. Menentukan dan mengonfigurasi model
  2. Menentukan dan menggunakan alat
  3. (Opsional) Histori chat Play Store
  4. (Opsional) Menyesuaikan template perintah
  5. (Opsional) Menyesuaikan orkestrasi

Sebelum memulai

Sebelum menjalankan tutorial ini, pastikan lingkungan Anda disiapkan dengan mengikuti langkah-langkah dalam Menyiapkan lingkungan Anda.

Langkah 1. Menentukan dan mengonfigurasi model

Jalankan langkah-langkah berikut untuk menentukan dan mengonfigurasi model Anda:

  1. Anda harus menentukan Versi model yang akan digunakan.

    model = "gemini-1.5-flash-001"

  2. (Opsional) Anda dapat mengonfigurasi setelan keamanan model. Untuk mempelajari lebih lanjut opsi yang tersedia untuk setelan keamanan di Gemini, lihat Mengonfigurasi atribut keamanan.

    Berikut adalah contoh cara mengonfigurasi setelan keamanan:

    from langchain_google_vertexai import HarmBlockThreshold, HarmCategory

safety_settings = {
    HarmCategory.HARM_CATEGORY_UNSPECIFIED: HarmBlockThreshold.BLOCK_NONE,
    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
}

  3. (Opsional) Anda dapat menentukan parameter model dengan cara berikut:

    model_kwargs = {
    # temperature (float): The sampling temperature controls the degree of
    # randomness in token selection.
    "temperature": 0.28,
    # max_output_tokens (int): The token limit determines the maximum amount of
    # text output from one prompt.
    "max_output_tokens": 1000,
    # top_p (float): Tokens are selected from most probable to least until
    # the sum of their probabilities equals the top-p value.
    "top_p": 0.95,
    # top_k (int): The next token is selected from among the top-k most
    # probable tokens. This is not supported by all model versions. See
    # https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/image-understanding#valid_parameter_values
    # for details.
    "top_k": None,
    # safety_settings (Dict[HarmCategory, HarmBlockThreshold]): The safety
    # settings to use for generating content.
    # (you must create your safety settings using the previous step first).
    "safety_settings": safety_settings,
}

Sekarang Anda dapat membuat dan mengkueri LangchainAgent menggunakan konfigurasi model:

agent = reasoning_engines.LangchainAgent(
    model=model,                # Required.
    model_kwargs=model_kwargs,  # Optional.
)

response = agent.query(input="What is the exchange rate from US dollars to Swedish currency?")

Responsnya adalah kamus Python yang mirip dengan contoh berikut:

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 "output": """I cannot provide the live exchange rate from US dollars to Swedish currency (Swedish krona, SEK).

**Here's why:**

* **Exchange rates constantly fluctuate.** Factors like global economics, interest rates, and political events cause
  these changes throughout the day.
* **Providing inaccurate information would be misleading.**

**How to find the current exchange rate:**

1. **Use a reliable online converter:** Many websites specialize in live exchange rates. Some popular options include:
   * Google Finance (google.com/finance)
   * XE.com
   * Bank websites (like Bank of America, Chase, etc.)
2. **Contact your bank or financial institution:** They can give you the exact exchange rate they are using.

Remember to factor in any fees or commissions when exchanging currency.
"""}

(Opsional) Penyesuaian lanjutan

Secara default, template LangchainAgent menggunakan ChatVertexAI karena memberikan akses ke semua model dasar yang tersedia di Google Cloud. Untuk menggunakan model yang tidak tersedia melalui ChatVertexAI, Anda dapat menentukan argumen model_builder=, dengan fungsi Python dari signature berikut:

from typing import Optional

def model_builder(
    *,
    model_name: str,                      # Required. The name of the model
    model_kwargs: Optional[dict] = None,  # Optional. The model keyword arguments.
    **kwargs,                             # Optional. The remaining keyword arguments to be ignored.
):

Untuk daftar model obrolan yang didukung di LangChain dan kemampuannya, lihat Model Chat. Kumpulan nilai yang didukung untuk model= dan model_kwargs= dikhususkan untuk setiap model obrolan, jadi Anda harus merujuk ke dokumentasi mereka yang sesuai untuk spesifikasi pendukung.

ChatVertexAI

Diinstal secara default.

Ini digunakan dalam template LangchainAgent saat Anda menghilangkan model_builder Anda, misalnya

agent = reasoning_engines.LangchainAgent(
    model=model,                # Required.
    model_kwargs=model_kwargs,  # Optional.
)

ChatAnthropic

Pertama, ikuti dokumentasi mereka untuk menyiapkan akun dan menginstal paket.

Selanjutnya, tentukan model_builder yang menampilkan ChatAnthropic:

def model_builder(*, model_name: str, model_kwargs = None, **kwargs):
    from langchain_anthropic import ChatAnthropic
    return ChatAnthropic(model_name=model_name, **model_kwargs)

Terakhir, gunakan dalam template LangchainAgent dengan kode berikut:

agent = reasoning_engines.LangchainAgent(
    model="claude-3-opus-20240229",                       # Required.
    model_builder=model_builder,                          # Required.
    model_kwargs={
        "api_key": "ANTHROPIC_API_KEY",  # Required.
        "temperature": 0.28,                              # Optional.
        "max_tokens": 1000,                               # Optional.
    },
)

ChatOpenAI

Anda dapat menggunakan ChatOpenAI bersama dengan ChatCompletions API Gemini.

Pertama, ikuti dokumentasi mereka untuk menginstal paket.

Selanjutnya, tentukan model_builder yang menampilkan ChatOpenAI:

def model_builder(
    *,
    model_name: str,
    model_kwargs = None,
    project: str,   # Specified via vertexai.init
    location: str,  # Specified via vertexai.init
    **kwargs,
):
    import google.auth
    from langchain_openai import ChatOpenAI

    # Note: the credential lives for 1 hour by default.
    # After expiration, it must be refreshed.
    creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
    auth_req = google.auth.transport.requests.Request()
    creds.refresh(auth_req)

    if model_kwargs is None:
        model_kwargs = {}

    endpoint = f"https://{location}-aiplatform.googleapis.com"
    base_url = f'{endpoint}/v1beta1/projects/{project}/locations/{location}/endpoints/openapi'

    return ChatOpenAI(
        model=model_name,
        base_url=base_url,
        **model_kwargs,
    )

Terakhir, gunakan dalam template LangchainAgent dengan kode berikut:

agent = reasoning_engines.LangchainAgent(
    model="google/gemini-1.5-pro-001",  # Or "meta/llama3-405b-instruct-maas"
    model_builder=model_builder,        # Required.
    model_kwargs={
        "temperature": 0,               # Optional.
        "max_retries": 2,               # Optional.
    },
)

Langkah 2. Menentukan dan menggunakan alat

Setelah menentukan model, langkah selanjutnya adalah menentukan alat yang digunakan model untuk penalaran. Sebuah {i>tool<i} dapat berupa Alat LangChain atau Python fungsi tersebut. Anda juga dapat mengonversi fungsi Python yang telah ditentukan menjadi Alat LangChain. Aplikasi ini menggunakan definisi fungsi.

Saat Anda menentukan fungsi, penting untuk menyertakan komentar yang menggambarkan dengan jelas parameter {i>function<i}, apa yang dilakukan fungsi itu, dan apa ditampilkan. Informasi ini digunakan model untuk menentukan fungsi yang akan digunakan. Anda juga harus menguji fungsi secara lokal untuk mengonfirmasi bahwa fungsi tersebut berhasil.

Gunakan kode berikut untuk menentukan fungsi yang menampilkan nilai tukar:

def get_exchange_rate(
    currency_from: str = "USD",
    currency_to: str = "EUR",
    currency_date: str = "latest",
):
    """Retrieves the exchange rate between two currencies on a specified date.

    Uses the Frankfurter API (https://api.frankfurter.app/) to obtain
    exchange rate data.

    Args:
        currency_from: The base currency (3-letter currency code).
            Defaults to "USD" (US Dollar).
        currency_to: The target currency (3-letter currency code).
            Defaults to "EUR" (Euro).
        currency_date: The date for which to retrieve the exchange rate.
            Defaults to "latest" for the most recent exchange rate data.
            Can be specified in YYYY-MM-DD format for historical rates.

    Returns:
        dict: A dictionary containing the exchange rate information.
            Example: {"amount": 1.0, "base": "USD", "date": "2023-11-24",
                "rates": {"EUR": 0.95534}}
    """
    import requests
    response = requests.get(
        f"https://api.frankfurter.app/{currency_date}",
        params={"from": currency_from, "to": currency_to},
    )
    return response.json()

Untuk menguji fungsi sebelum Anda menggunakannya di aplikasi Anda, jalankan perintah berikut:

get_exchange_rate(currency_from="USD", currency_to="SEK")

Responsnya akan terlihat seperti berikut:

{'amount': 1.0, 'base': 'USD', 'date': '2024-02-22', 'rates': {'SEK': 10.3043}}

Untuk menggunakan alat di dalam template LangchainAgent, Anda akan menambahkannya ke daftar alat berdasarkan argumen tools=:

agent = reasoning_engines.LangchainAgent(
    model=model,                # Required.
    tools=[get_exchange_rate],  # Optional.
    model_kwargs=model_kwargs,  # Optional.
)

Anda dapat menguji aplikasi dengan melakukan kueri pengujian. Jalankan perintah berikut untuk menguji aplikasi menggunakan dolar AS dan Krona Swedia:

response = agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?"
)

Responsnya berupa kamus yang mirip dengan yang berikut ini:

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 "output": "For 1 US dollar you will get 10.7345 Swedish Krona."}

(Opsional) Beberapa alat

Alat untuk LangchainAgent dapat ditentukan dan dibuat instance-nya dengan cara lain.

Alat Grounding

Pertama, impor paket generate_models dan buat alat

from vertexai.generative_models import grounding, Tool

grounded_search_tool = Tool.from_google_search_retrieval(
    grounding.GoogleSearchRetrieval()
)

Selanjutnya, gunakan alat di dalam template LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[grounded_search_tool],
)
agent.query(input="When is the next total solar eclipse in US?")

Responsnya berupa kamus yang mirip dengan yang berikut ini:

{"input": "When is the next total solar eclipse in US?",
 "output": """The next total solar eclipse in the U.S. will be on August 23, 2044.
 This eclipse will be visible from three states: Montana, North Dakota, and
 South Dakota. The path of totality will begin in Greenland, travel through
 Canada, and end around sunset in the United States."""}

Untuk mengetahui detailnya, buka Grounding.

Alat LangChain

Pertama, instal paket yang mendefinisikan alat tersebut.

pip install langchain-google-community

Selanjutnya, impor paket dan buat alat (tool).

from langchain_google_community import VertexAISearchRetriever
from langchain.tools.retriever import create_retriever_tool

retriever = VertexAISearchRetriever(
    project_id="PROJECT_ID",
    data_store_id="DATA_STORE_ID",
    location_id="DATA_STORE_LOCATION_ID",
    engine_data_type=1,
    max_documents=10,
)
movie_search_tool = create_retriever_tool(
    retriever=retriever,
    name="search_movies",
    description="Searches information about movies.",
)

Terakhir, gunakan alat di dalam template LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[movie_search_tool],
)
response = agent.query(
    input="List some sci-fi movies from the 1990s",
)

Perintah ini akan menampilkan respons seperti

{"input": "When is the next total solar eclipse in US?",
 "output": """Here are some sci-fi movies from the 1990s:
    * The Matrix (1999): A computer hacker learns from mysterious rebels about the true nature of his reality and his role in the war against its controllers.
    * Star Wars: Episode I - The Phantom Menace (1999): Two Jedi Knights escape a hostile blockade to find a queen and her protector, and come across a young boy [...]
    * Men in Black (1997): A police officer joins a secret organization that monitors extraterrestrial interactions on Earth.
    [...]
 """}

Untuk melihat contoh lengkap, buka notebook.

Untuk contoh alat lainnya yang tersedia di LangChain, kunjungi Alat Google.

Ekstensi Vertex AI

Pertama, impor paket ekstensi dan buat alat

from typing import Optional

def generate_and_execute_code(
    query: str,
    files: Optional[list[str]] = None,
    file_gcs_uris: Optional[list[str]] = None,
) -> str:
    """Get the results of a natural language query by generating and executing
    a code snippet.

    Example queries: "Find the max in [1, 2, 5]" or "Plot average sales by
    year (from data.csv)". Only one of `file_gcs_uris` and `files` field
    should be provided.

    Args:
        query:
            The natural language query to generate and execute.
        file_gcs_uris:
            Optional. URIs of input files to use when executing the code
            snippet. For example, ["gs://input-bucket/data.csv"].
        files:
            Optional. Input files to use when executing the generated code.
            If specified, the file contents are expected be base64-encoded.
            For example: [{"name": "data.csv", "contents": "aXRlbTEsaXRlbTI="}].
    Returns:
        The results of the query.
    """
    operation_params = {"query": query}
    if files:
        operation_params["files"] = files
    if file_gcs_uris:
        operation_params["file_gcs_uris"] = file_gcs_uris

    from vertexai.preview import extensions

    # If you have an existing extension instance, you can get it here
    # i.e. code_interpreter = extensions.Extension(resource_name).
    code_interpreter = extensions.Extension.from_hub("code_interpreter")
    return extensions.Extension.from_hub("code_interpreter").execute(
        operation_id="generate_and_execute",
        operation_params=operation_params,
    )

Selanjutnya, gunakan alat di dalam template LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[generate_and_execute_code],
)
agent.query(
    input="""Using the data below, construct a bar chart that includes only the height values with different colors for the bars:

    tree_heights_prices = {
      \"Pine\": {\"height\": 100, \"price\": 100},
      \"Oak\": {\"height\": 65, \"price\": 135},
      \"Birch\": {\"height\": 45, \"price\": 80},
      \"Redwood\": {\"height\": 200, \"price\": 200},
      \"Fir\": {\"height\": 180, \"price\": 162},
    }
    """
)

Perintah ini akan menampilkan respons seperti

{"input": """Using the data below, construct a bar chart that includes only the height values with different colors for the bars:

 tree_heights_prices = {
    \"Pine\": {\"height\": 100, \"price\": 100},
    \"Oak\": {\"height\": 65, \"price\": 135},
    \"Birch\": {\"height\": 45, \"price\": 80},
    \"Redwood\": {\"height\": 200, \"price\": 200},
    \"Fir\": {\"height\": 180, \"price\": 162},
 }
 """,
 "output": """Here's the generated bar chart:
 ```python
 import matplotlib.pyplot as plt

 tree_heights_prices = {
    "Pine": {"height": 100, "price": 100},
    "Oak": {"height": 65, "price": 135},
    "Birch": {"height": 45, "price": 80},
    "Redwood": {"height": 200, "price": 200},
    "Fir": {"height": 180, "price": 162},
 }

 heights = [tree["height"] for tree in tree_heights_prices.values()]
 names = list(tree_heights_prices.keys())

 plt.bar(names, heights, color=['red', 'green', 'blue', 'purple', 'orange'])
 plt.xlabel('Tree Species')
 plt.ylabel('Height')
 plt.title('Tree Heights')
 plt.show()
 ```
 """}

Untuk mengetahui detailnya, buka Ekstensi Vertex AI.

Anda dapat menggunakan semua (atau sebagian) alat yang telah Anda buat di LangchainAgent:

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[
        get_exchange_rate,         # Optional (Python function)
        grounded_search_tool,      # Optional (Grounding Tool)
        movie_search_tool,         # Optional (Langchain Tool)
        generate_and_execute_code, # Optional (Vertex Extension)
    ],
)

agent.query(input="When is the next total solar eclipse in US?")

(Opsional) Konfigurasi alat

Dengan Gemini, Anda dapat membatasi penggunaan alat. Misalnya, alih-alih memungkinkan model menghasilkan respons natural language, Anda bisa memaksanya untuk hanya menghasilkan panggilan fungsi ("panggilan fungsi paksa").

from vertexai.preview.generative_models import ToolConfig

agent = reasoning_engines.LangchainAgent(
    model="gemini-1.5-pro",
    tools=[search_arxiv, get_exchange_rate],
    model_tool_kwargs={
        "tool_config": {  # Specify the tool configuration here.
            "function_calling_config": {
                "mode": ToolConfig.FunctionCallingConfig.Mode.ANY,
                "allowed_function_names": ["search_arxiv", "get_exchange_rate"],
            },
        },
    },
)

agent.query(
    input="Explain the Schrodinger equation in a few sentences",
)

Untuk mengetahui detailnya, buka Konfigurasi Alat.

Langkah 3. Simpan histori chat

Untuk melacak pesan chat dan menambahkannya ke database, tentukan get_session_history, lalu teruskan saat Anda membuat agen. Ini fungsi harus mengambil session_id dan menampilkan BaseChatMessageHistory .

  • session_id adalah ID untuk sesi tempat pesan input ini berada tempat mesin terhubung. Hal ini memungkinkan Anda mengelola beberapa percakapan sekaligus.
  • BaseChatMessageHistory adalah antarmuka untuk class yang dapat memuat dan menyimpan objek pesan.

Menyiapkan database

Untuk daftar penyedia ChatMessageHistory dari Google yang didukung di LangChain, lihat Memori.

Firestore (Native)

Pertama, ikuti dokumentasi LangChain untuk menyiapkan database dan menginstal paket.

Selanjutnya, tentukan fungsi get_session_history sebagai berikut:

def get_session_history(session_id: str):
    from langchain_google_firestore import FirestoreChatMessageHistory
    from google.cloud import firestore

    client = firestore.Client(project="PROJECT_ID")
    return FirestoreChatMessageHistory(
        client=client,
        session_id=session_id,
        collection="TABLE_NAME",
        encode_message=False,
    )

Buat agen dan teruskan sebagai chat_history:

agent = reasoning_engines.LangchainAgent(
    model=model,
    chat_history=get_session_history,  # <- new
)

Bigtable

Pertama, ikuti dokumentasi LangChain untuk menyiapkan database dan menginstal paket.

Selanjutnya, tentukan fungsi get_session_history sebagai berikut:

def get_session_history(session_id: str):
    from langchain_google_bigtable import BigtableChatMessageHistory

    return BigtableChatMessageHistory(
        instance_id="INSTANCE_ID",
        table_id="TABLE_NAME",
        session_id=session_id,
    )

Buat agen dan teruskan sebagai chat_history:

agent = reasoning_engines.LangchainAgent(
    model=model,
    chat_history=get_session_history,  # <- new
)

Spanner

Pertama, ikuti dokumentasi LangChain untuk menyiapkan database dan menginstal paket.

Selanjutnya, tentukan fungsi get_session_history sebagai berikut:

def get_session_history(session_id: str):
    from langchain_google_spanner import SpannerChatMessageHistory

    return SpannerChatMessageHistory(
        instance_id="INSTANCE_ID",
        database_id="DATABASE_ID",
        table_name="TABLE_NAME",
        session_id=session_id,
    )

Buat agen dan teruskan sebagai chat_history:

agent = reasoning_engines.LangchainAgent(
    model=model,
    chat_history=get_session_history,  # <- new
)

Saat membuat kueri agen, pastikan Anda meneruskan session_id agar agen memiliki "memori" pertanyaan dan jawaban sebelumnya:

agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?",
    config={"configurable": {"session_id": "SESSION_ID"}},
)

Langkah 4. Menyesuaikan template perintah

Template perintah membantu menerjemahkan input pengguna menjadi instruksi untuk model, dan digunakan untuk memandu respons model, membantunya memahami konteks dan menghasilkan output berbasis bahasa yang relevan dan koheren. Untuk mengetahui detailnya, buka ChatPromptTemplates.

Template perintah default disusun secara berurutan menjadi bagian-bagian.

Bagian Deskripsi
(Opsional) Petunjuk sistem Petunjuk penerapan agen di semua kueri.
(Opsional) Histori chat Pesan yang sesuai dengan histori chat dari sesi sebelumnya.
Input pengguna Kueri dari pengguna yang akan direspons oleh agen.
Playbook Agen Pesan yang dibuat oleh agen (misalnya dengan panggilan fungsi) seperti yang menggunakan alatnya dan melakukan penalaran untuk merumuskan respons terhadap pengguna.

Template perintah default akan dibuat jika Anda membuat agen tanpa menentukan template perintah Anda sendiri, dan tampilannya akan lengkap seperti berikut:

from langchain_core.prompts import ChatPromptTemplate
from langchain.agents.format_scratchpad.tools import format_to_tool_messages

prompt_template = {
    "user_input": lambda x: x["input"],
    "history": lambda x: x["history"],
    "agent_scratchpad": lambda x: format_to_tool_messages(x["intermediate_steps"]),
} | ChatPromptTemplate.from_messages([
    ("system", "{system_instruction}"),
    ("placeholder", "{history}"),
    ("user", "{user_input}"),
    ("placeholder", "{agent_scratchpad}"),
])

Anda dapat mengganti template perintah default dengan template perintah Anda sendiri, dan menggunakannya saat merancang agen, misalnya:


custom_prompt_template = {
    "user_input": lambda x: x["input"],
    "history": lambda x: x["history"],
    "agent_scratchpad": lambda x: format_to_tool_messages(x["intermediate_steps"]),
} | ChatPromptTemplate.from_messages([
    ("placeholder", "{history}"),
    ("user", "{user_input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = reasoning_engines.LangchainAgent(
    model=model,
    prompt=custom_prompt_template,
    chat_history=get_session_history,
    tools=[get_exchange_rate],
)

agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?",
    config={"configurable": {"session_id": "SESSION_ID"}},
)

Langkah 5. Menyesuaikan orkestrasi

Semua komponen LangChain mengimplementasikan antarmuka Runnable, yang menyediakan skema input dan {i>output<i} untuk orkestrasi. LangchainAgent memerlukan runnable yang dibangun agar dapat merespons kueri. Secara {i>default<i}, LangchainAgent akan membuat runnable semacam itu dengan mengikat model dengan alat dan gunakan AgentExecutor yang digabungkan menjadi RunnableWithMessageHistory jika histori chat diaktifkan.

Anda mungkin ingin menyesuaikan orkestrasi jika Anda ingin (i) mengimplementasikan agen yang melakukan serangkaian langkah determenistik (bukan melakukan penalaran terbuka), atau (ii) meminta Agen dengan cara seperti ReAct untuk anotasikan setiap langkah dengan pemikiran mengapa mereka melakukan langkah itu. Untuk melakukannya, Anda perlu harus mengganti runnable default saat membuat LangchainAgent dengan menentukan argumen runnable_builder= dengan fungsi Python tanda tangan berikut:

from typing import Optional
from langchain_core.language_models import BaseLanguageModel

def runnable_builder(
    model: BaseLanguageModel,
    *,
    system_instruction: Optional[str] = None,
    prompt: Optional["RunnableSerializable"] = None,
    tools: Optional[Sequence["_ToolLike"]] = None,
    chat_history: Optional["GetSessionHistoryCallable"] = None,
    model_tool_kwargs: Optional[Mapping[str, Any]] = None,
    agent_executor_kwargs: Optional[Mapping[str, Any]] = None,
    runnable_kwargs: Optional[Mapping[str, Any]] = None,
    **kwargs,
):

di mana

Ini memberikan berbagai opsi untuk menyesuaikan logika orkestrasi.

ChatModel

Dalam kasus paling sederhana, untuk membuat agen tanpa orkestrasi, Anda bisa mengganti runnable_builder untuk LangchainAgent guna menampilkan model secara langsung.

from langchain_core.language_models import BaseLanguageModel

def llm_builder(model: BaseLanguageModel, **kwargs):
    return model

agent = reasoning_engines.LangchainAgent(
    model=model,
    runnable_builder=llm_builder,
)

ReAct

Untuk mengganti perilaku panggilan alat default dengan agen ReAct Anda sendiri berdasarkan prompt Anda sendiri (lihat Menyesuaikan Template Prompt), Anda harus mengganti runnable_builder untuk LangchainAgent.

from typing import Sequence
from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import BasePromptTemplate
from langchain_core.tools import BaseTool
from langchain import hub

def react_builder(
    model: BaseLanguageModel,
    *,
    tools: Sequence[BaseTool],
    prompt: BasePromptTemplate,
    agent_executor_kwargs = None,
    **kwargs,
):
    from langchain.agents.react.agent import create_react_agent
    from langchain.agents import AgentExecutor

    agent = create_react_agent(model, tools, prompt)
    return AgentExecutor(agent=agent, tools=tools, **agent_executor_kwargs)

agent = reasoning_engines.LangchainAgent(
    model=model,
    tools=[get_exchange_rate],
    prompt=hub.pull("hwchase17/react"),
    agent_executor_kwargs={"verbose": True}, # Optional. For illustration.
    runnable_builder=react_builder,
)

Sintaksis LCEL

Untuk membuat grafik berikut menggunakan LangChain Expression Language (LCEL),

   Input
   /   \
 Pros  Cons
   \   /
  Summary

Anda perlu mengganti runnable_builder untuk LangchainAgent:

def lcel_builder(*, model, **kwargs):
    from operator import itemgetter
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.runnables import RunnablePassthrough
    from langchain_core.output_parsers import StrOutputParser

    output_parser = StrOutputParser()

    planner = ChatPromptTemplate.from_template(
        "Generate an argument about: {input}"
    ) | model | output_parser | {"argument": RunnablePassthrough()}

    pros = ChatPromptTemplate.from_template(
        "List the positive aspects of {argument}"
    ) | model | output_parser

    cons = ChatPromptTemplate.from_template(
        "List the negative aspects of {argument}"
    ) | model | output_parser

    final_responder = ChatPromptTemplate.from_template(
        "Argument:{argument}\nPros:\n{pros}\n\nCons:\n{cons}\n"
        "Generate a final response given the critique",
    ) | model | output_parser

    return planner | {
        "pros": pros,
        "cons": cons,
        "argument": itemgetter("argument"),
    } | final_responder

agent = reasoning_engines.LangchainAgent(
    model=model,
    runnable_builder=lcel_builder,
)

LangGraph

Untuk membuat grafik berikut menggunakan LangGraph,

   Input
   /   \
 Pros  Cons
   \   /
  Summary

Anda perlu mengganti runnable_builder untuk LangchainAgent:

def langgraph_builder(*, model, **kwargs):
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.output_parsers import StrOutputParser
    from langgraph.graph import END, MessageGraph

    output_parser = StrOutputParser()

    planner = ChatPromptTemplate.from_template(
        "Generate an argument about: {input}"
    ) | model | output_parser

    pros = ChatPromptTemplate.from_template(
        "List the positive aspects of {input}"
    ) | model | output_parser

    cons = ChatPromptTemplate.from_template(
        "List the negative aspects of {input}"
    ) | model | output_parser

    summary = ChatPromptTemplate.from_template(
        "Input:{input}\nGenerate a final response given the critique",
    ) | model | output_parser

    builder = MessageGraph()
    builder.add_node("planner", planner)
    builder.add_node("pros", pros)
    builder.add_node("cons", cons)
    builder.add_node("summary", summary)

    builder.add_edge("planner", "pros")
    builder.add_edge("planner", "cons")
    builder.add_edge("pros", "summary")
    builder.add_edge("cons", "summary")
    builder.add_edge("summary", END)
    builder.set_entry_point("planner")
    return builder.compile()

agent = reasoning_engines.LangchainAgent(
    model=model,
    runnable_builder=langgraph_builder,
)

# Example query
agent.query(input={"role": "user", "content": "scrum methodology"})

Langkah selanjutnya