Vertex AI에서 LangChain을 사용하여 만들 수 있는 소규모 애플리케이션 중 지정된 날짜에 두 통화 간 환율을 반환하는 애플리케이션이 있습니다.
자체 Python 클래스를 정의하거나(애플리케이션 템플릿 맞춤설정 참조), Vertex AI SDK for Python에서 에이전트에 대해 LangchainAgent 클래스를 사용할 수 있습니다. 다음 단계에서는 LangchainAgent 사전 빌드된 템플릿을 사용하여 이 애플리케이션을 만드는 방법을 보여줍니다.
- 모델 정의 및 구성
- 도구 정의 및 사용
- (선택사항) 채팅 기록 저장
- (선택사항) 프롬프트 템플릿 맞춤설정
- (선택사항) 조정 맞춤설정
시작하기 전에
이 튜토리얼을 실행하기 전에 환경 설정 단계에 따라 환경이 설정되었는지 확인합니다.
1단계: 모델 정의 및 구성
다음 단계를 실행하여 모델을 정의하고 구성합니다.
사용할 모델 버전을 정의해야 합니다.
model = "gemini-1.5-flash-001"(선택사항) 모델의 안전 설정을 구성할 수 있습니다. Gemini에서 안전 설정에 사용할 수 있는 옵션에 대한 자세한 내용은 안전 속성 구성을 참조하세요.
다음은 안전 설정을 구성하는 방법의 예시입니다.
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, }(선택사항) 다음과 같이 모델 파라미터를 지정할 수 있습니다.
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, }
이제 모델 구성을 사용하여 LangchainAgent를 만들고 쿼리할 수 있습니다.
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?")
응답은 다음 예시와 유사한 Python 사전입니다.
{"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.
"""}
(선택사항) 고급 맞춤설정
LangchainAgent 템플릿은 ChatVertexAI가 Google Cloud에서 사용 가능한 모든 파운데이션 모델에 대한 액세스를 제공하므로 기본적으로 이를 사용합니다. ChatVertexAI를 통해 사용할 수 없는 모델을 사용하려면 다음 서명이 있는 Python 함수와 함께 model_builder= 인수를 지정하면 됩니다.
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.
):
LangChain에서 지원되는 채팅 모델과 기능의 목록은 채팅 모델을 참조하세요.
model= 및 model_kwargs=에 지원되는 값 집합은 각 채팅 모델에 따라 다르므로 자세한 내용은 해당 문서를 참조하세요.
ChatVertexAI
기본적으로 설치되어 있습니다.
model_builder 인수를 생략하면 LangchainAgent 템플릿에서 사용됩니다. 예를 들면 다음과 같습니다.
agent = reasoning_engines.LangchainAgent(
model=model, # Required.
model_kwargs=model_kwargs, # Optional.
)
ChatAnthropic
먼저 문서에 따라 계정을 설정하고 패키지를 설치합니다.
다음으로 ChatAnthropic을 반환하는 model_builder를 정의합니다.
def model_builder(*, model_name: str, model_kwargs = None, **kwargs):
from langchain_anthropic import ChatAnthropic
return ChatAnthropic(model_name=model_name, **model_kwargs)
마지막으로 다음 코드를 사용하여 LangchainAgent 템플릿에서 사용합니다.
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
ChatOpenAI를 Gemini의 ChatCompletions API와 함께 사용할 수 있습니다.
먼저 문서에 따라 패키지를 설치합니다.
다음으로 ChatOpenAI을 반환하는 model_builder를 정의합니다.
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,
)
마지막으로 다음 코드를 사용하여 LangchainAgent 템플릿에서 사용합니다.
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.
},
)
2단계: 도구 정의 및 사용
모델을 정의한 후 다음 단계는 추론을 위해 모델에 사용되는 도구를 정의하는 것입니다. 도구는 LangChain 도구 또는 Python 함수일 수 있습니다. 또한 정의된 Python 함수를 LangChain 도구로 변환할 수 있습니다. 이 애플리케이션은 함수 정의를 사용합니다.
함수를 정의할 때는 함수 매개변수, 함수 기능 및 함수 반환값을 완전히 명확하게 기술하는 설명을 포함하는 것이 중요합니다. 이 정보는 모델이 사용할 함수를 결정하기 위해 사용됩니다. 또한 함수를 로컬로 테스트하여 작동하는지 확인해야 합니다.
다음 코드를 사용하여 환율을 반환하는 함수를 정의합니다.
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()
애플리케이션에 사용하기 전에 함수를 테스트하기 위해 다음을 실행합니다.
get_exchange_rate(currency_from="USD", currency_to="SEK")
응답은 다음과 비슷하게 표시됩니다.
{'amount': 1.0, 'base': 'USD', 'date': '2024-02-22', 'rates': {'SEK': 10.3043}}
LangchainAgent 템플릿 내에서 도구를 사용하려면 도구를 tools= 인수 아래의 도구 목록에 추가합니다.
agent = reasoning_engines.LangchainAgent(
model=model, # Required.
tools=[get_exchange_rate], # Optional.
model_kwargs=model_kwargs, # Optional.
)
테스트 쿼리를 수행하여 애플리케이션을 테스트할 수 있습니다. 다음 명령어를 실행하여 US 달러와 스웨덴 크로나를 사용해 애플리케이션을 테스트합니다.
response = agent.query(
input="What is the exchange rate from US dollars to Swedish currency?"
)
응답은 다음과 유사한 딕셔너리입니다.
{"input": "What is the exchange rate from US dollars to Swedish currency?",
"output": "For 1 US dollar you will get 10.7345 Swedish Krona."}
(선택사항) 여러 도구
LangchainAgent용 도구를 다른 방식으로 정의하고 인스턴스화할 수 있습니다.
그라운딩 도구
먼저 generate_models 패키지를 가져오고 도구를 만듭니다.
from vertexai.generative_models import grounding, Tool
grounded_search_tool = Tool.from_google_search_retrieval(
grounding.GoogleSearchRetrieval()
)
다음으로 LangchainAgent 템플릿 내에서 도구를 사용합니다.
agent = reasoning_engines.LangchainAgent(
model=model,
tools=[grounded_search_tool],
)
agent.query(input="When is the next total solar eclipse in US?")
응답은 다음과 유사한 사전입니다.
{"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."""}
자세한 내용은 그라운딩을 참조하세요.
LangChain 도구
먼저 도구를 정의하는 패키지를 설치합니다.
pip install langchain-google-community다음으로 패키지를 가져오고 도구를 만듭니다.
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.",
)
마지막으로 LangchainAgent 템플릿 내에서 도구를 사용합니다.
agent = reasoning_engines.LangchainAgent(
model=model,
tools=[movie_search_tool],
)
response = agent.query(
input="List some sci-fi movies from the 1990s",
)
다음과 같은 응답이 반환되어야 합니다.
{"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.
[...]
"""}
전체 예시를 보려면 노트북을 참조하세요.
LangChain에서 사용할 수 있는 도구의 추가 예시는 Google 도구를 참조하세요.
Vertex AI Extension
먼저 확장 프로그램 패키지를 가져오고 도구를 만듭니다.
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,
)
다음으로 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},
}
"""
)
다음과 같은 응답이 반환되어야 합니다.
{"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()
```
"""}
자세한 내용은 Vertex AI 확장 프로그램을 참조하세요.
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?")
(선택사항) 도구 구성
Gemini를 사용하면 도구 사용에 제약조건을 적용할 수 있습니다. 예를 들어 모델에서 자연어 응답을 생성하도록 허용하는 대신 함수 호출만 생성하도록 강제할 수 있습니다('강제 함수 호출').
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",
)
자세한 내용은 도구 구성을 참조하세요.
3단계: 채팅 기록 저장
채팅 메시지를 추적하고 데이터베이스에 추가하려면 get_session_history 함수를 정의하고 에이전트를 만들 때 전달합니다. 이 함수는 session_id를 사용하고 BaseChatMessageHistory 객체를 반환해야 합니다.
session_id는 이러한 입력 메시지가 속한 세션의 식별자입니다. 이를 통해 여러 대화를 동시에 유지할 수 있습니다.BaseChatMessageHistory는 메시지 객체를 로드하고 저장할 수 있는 클래스의 인터페이스입니다.
데이터베이스 설정
LangChain에서 지원되는 Google의 ChatMessageHistory 제공업체 목록은 메모리를 참조하세요.
Firestore(네이티브)
먼저 LangChain의 문서에 따라 데이터베이스를 설정하고 패키지를 설치합니다.
다음으로 get_session_history 함수를 다음과 같이 정의합니다.
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,
)
에이전트를 만들고 chat_history로 전달합니다.
agent = reasoning_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
Bigtable
먼저 LangChain의 문서에 따라 데이터베이스를 설정하고 패키지를 설치합니다.
다음으로 get_session_history 함수를 다음과 같이 정의합니다.
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,
)
에이전트를 만들고 chat_history로 전달합니다.
agent = reasoning_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
Spanner
먼저 LangChain의 문서에 따라 데이터베이스를 설정하고 패키지를 설치합니다.
다음으로 get_session_history 함수를 다음과 같이 정의합니다.
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,
)
에이전트를 만들고 chat_history로 전달합니다.
agent = reasoning_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
에이전트를 쿼리할 때는 에이전트에 이전 질문과 답변의 '메모리'가 있도록 session_id를 전달해야 합니다.
agent.query(
input="What is the exchange rate from US dollars to Swedish currency?",
config={"configurable": {"session_id": "SESSION_ID"}},
)
4단계: 프롬프트 템플릿 맞춤설정
프롬프트 템플릿은 사용자 입력을 모델의 안내로 변환하는 데 도움이 되며 모델의 응답을 안내하는 데 사용되므로 컨텍스트를 이해하고 관련성 높고 일관된 언어 기반 출력을 생성할 수 있습니다. 자세한 내용은 ChatPromptTemplates를 참조하세요.
기본 프롬프트 템플릿은 섹션별로 순차 구성됩니다.
| 섹션 | 설명 |
|---|---|
| (선택사항) 시스템 안내 | 에이전트가 모든 쿼리에 적용할 안내입니다. |
| (선택사항) 채팅 기록 | 이전 세션의 채팅 기록에 해당하는 메시지입니다. |
| 사용자 입력 | 에이전트가 응답하는 데 사용하는 사용자의 쿼리입니다. |
| 에이전트 스크래치패드 | 에이전트에서 도구를 사용하고 추론을 수행하여 사용자에게 응답할 때 생성하는 메시지(예: 함수 호출)입니다. |
기본 프롬프트 템플릿은 자체 프롬프트 템플릿을 지정하지 않고 에이전트를 만드는 경우에 생성되며 다음과 같이 전체가 표시됩니다.
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}"),
])
기본 프롬프트 템플릿을 자체 프롬프트 템플릿으로 재정의하고 에이전트를 구성할 때 사용할 수 있습니다. 예를 들면 다음과 같습니다.
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"}},
)
5단계: 조정 맞춤설정
모든 LangChain 구성요소는 조정의 입력 및 출력 스키마를 제공하는 실행 파일 인터페이스를 구현합니다. LangchainAgent가 쿼리에 응답하면 실행 파일을 빌드해야 합니다. 기본적으로 LangchainAgent는 도구로 모델을 바인딩하여 이러한 실행 파일을 빌드하고 채팅 기록이 사용 설정된 경우 RunnableWithMessageHistory로 래핑된 AgentExecutor를 사용합니다.
(i) 개방형 추론을 수행하는 대신 결정론적 단계 집합을 수행하는 에이전트를 구현하거나 (ii) ReAct와 같은 방식으로 에이전트에게 해당 단계를 수행한 이유에 대한 사고로 각 단계에 주석으로 추가하도록 프롬프트하려는 경우에 조정을 맞춤설정하는 것이 좋습니다. 이렇게 하려면 다음 서명의 Python 함수로 runnable_builder= 인수를 지정하여 LangchainAgent를 만들 때 기본 실행 파일을 재정의해야 합니다.
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,
):
각 항목의 의미는 다음과 같습니다.
model은model_builder에서 반환되는 채팅 모델에 해당합니다(모델 정의 및 구성 참조).tools및model_tool_kwargs는 사용할 도구와 구성에 해당합니다(도구 정의 및 사용 참조).chat_history: 채팅 메시지를 저장하는 데이터베이스에 해당합니다(채팅 기록 저장 참조).system_instruction및prompt는 프롬프트 구성에 해당합니다(프롬프트 템플릿 맞춤설정 참조).agent_executor_kwargs및runnable_kwargs는 빌드할 실행 파일을 맞춤설정하는 데 사용할 수 있는 키워드 인수입니다.
이를 통해 조정 로직을 맞춤설정할 수 있는 다양한 옵션이 제공됩니다.
ChatModel
가장 간단한 경우 조정 없이 에이전트를 만들려면 LangchainAgent의 runnable_builder를 재정의하여 model을 직접 반환하면 됩니다.
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
자체 prompt(프롬프트 템플릿 맞춤설정 참조)를 기반으로 자체 ReAct 에이전트를 사용하여 기본 도구 호출 동작을 재정의하려면 LangchainAgent의 runnable_builder를 재정의해야 합니다.
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,
)
LCEL 구문
LangChain Expression Language(LCEL)를 사용하여 다음 그래프를 구성하려면
Input
/ \
Pros Cons
\ /
Summary
LangchainAgent의 runnable_builder를 재정의해야 합니다.
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
LangGraph를 사용하여 다음 그래프를 구성하려면
Input
/ \
Pros Cons
\ /
Summary
LangchainAgent의 runnable_builder를 재정의해야 합니다.
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"})