Un esempio di una piccola applicazione che puoi creare utilizzando LangChain su Vertex AI è quella che restituisce il tasso di cambio tra due valute in una data specificata.
Puoi definire la tua classe Python (consulta
Personalizzare un modello di applicazione) o utilizzare la classe LangchainAgent nell'SDK Vertex AI per Python per il tuo agente. I passaggi che seguono mostrano come creare questa applicazione utilizzando il
LangchainAgent modello predefinito:
- Definire e configurare un modello
- Definire e utilizzare uno strumento
- (Facoltativo) Memorizzare la cronologia chat
- (Facoltativo) Personalizza il modello di prompt
- (Facoltativo) Personalizza l'orchestrazione
Prima di iniziare
Prima di eseguire questo tutorial, assicurati che il tuo ambiente sia configurato seguendo segui i passaggi descritti in Configurare l'ambiente.
Passaggio 1: Definire e configurare un modello
Per definire e configurare il modello, segui questi passaggi:
Devi definire la versione del modello da utilizzare.
model = "gemini-1.5-flash-001"(Facoltativo) Puoi configurare le impostazioni di sicurezza del modello. Per scoprire di più sulle opzioni disponibili per le impostazioni di sicurezza in Gemini, consulta Configurare gli attributi di sicurezza.
Di seguito è riportato un esempio di come puoi configurare le impostazioni di sicurezza:
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, }(Facoltativo) Puoi specificare i parametri del modello. nel seguente modo:
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, }
Ora puoi creare ed eseguire query su un LangchainAgent utilizzando le configurazioni del modello:
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?")
La risposta è un dizionario Python simile all'esempio seguente:
{"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.
"""}
(Facoltativo) Personalizzazione avanzata
Il modello LangchainAgent utilizza ChatVertexAI per impostazione predefinita, in quanto fornisce accesso a tutti i modelli di base disponibili in Google Cloud. Per utilizzare un modello non disponibile tramite ChatVertexAI, puoi specificare l'argomento model_builder= con una funzione Python della seguente firma:
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.
):
Per un elenco dei modelli di chat supportati in LangChain e delle relative funzionalità, consulta
Modelli di chat.
L'insieme di valori supportati per model= e model_kwargs= è specifico per
per ogni modello di chat, quindi devi fare riferimento alla documentazione corrispondente
i dettagli.
ChatVertexAI
Installato per impostazione predefinita.
Viene utilizzato nel modello LangchainAgent quando ometti l'argomento model_builder, ad esempio
agent = reasoning_engines.LangchainAgent(
model=model, # Required.
model_kwargs=model_kwargs, # Optional.
)
ChatAnthropic
Innanzitutto, segui la documentazione per configurare un account e installare il pacchetto.
Poi definisci un model_builder che restituisca ChatAnthropic:
def model_builder(*, model_name: str, model_kwargs = None, **kwargs):
from langchain_anthropic import ChatAnthropic
return ChatAnthropic(model_name=model_name, **model_kwargs)
Infine, utilizzalo nel modello LangchainAgent con il seguente codice:
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
Puoi utilizzare ChatOpenAI insieme all'API Chatcompletions di Gemini.
Innanzitutto, segui la documentazione per installare il pacchetto.
Poi definisci un model_builder che restituisca 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,
)
Infine, utilizzalo nel modello LangchainAgent con il seguente codice:
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.
},
)
Passaggio 2: Definisci e utilizza uno strumento
Dopo aver definito il modello, il passaggio successivo è definire gli strumenti utilizzato dal modello per il ragionamento. Uno strumento può essere un strumento LangChain o Python personalizzata. Puoi anche convertire una funzione Python definita in uno strumento LangChain. Questa applicazione utilizza una definizione di funzione.
Quando definisci la funzione, è importante includere commenti che riflettano in modo esaustivo e descrivere chiaramente i parametri della funzione, cosa fa la funzione e cosa restituite da una funzione. Queste informazioni vengono utilizzate dal modello per determinare da utilizzare. Devi anche testare la funzione localmente per confermare che funziona.
Utilizza il seguente codice per definire una funzione che restituisce un tasso di cambio:
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()
Per testare la funzione prima di utilizzarla nella tua applicazione, esegui quanto segue:
get_exchange_rate(currency_from="USD", currency_to="SEK")
La risposta dovrebbe essere simile alla seguente:
{'amount': 1.0, 'base': 'USD', 'date': '2024-02-22', 'rates': {'SEK': 10.3043}}
Per utilizzare lo strumento all'interno del modello LangchainAgent, devi aggiungerlo all'elenco degli strumenti nell'argomento tools=:
agent = reasoning_engines.LangchainAgent(
model=model, # Required.
tools=[get_exchange_rate], # Optional.
model_kwargs=model_kwargs, # Optional.
)
Puoi testare l'applicazione eseguendo query di test. Esegui questo comando per testare l'applicazione utilizzando dollari statunitensi e corone svedesi:
response = agent.query(
input="What is the exchange rate from US dollars to Swedish currency?"
)
La risposta è un dizionario simile al seguente:
{"input": "What is the exchange rate from US dollars to Swedish currency?",
"output": "For 1 US dollar you will get 10.7345 Swedish Krona."}
(Facoltativo) Più strumenti
Gli strumenti per LangchainAgent possono essere definiti e creati un'istanza in altri modi.
Strumento di grounding
Innanzitutto, importa il pacchetto generate_models e crea lo strumento
from vertexai.generative_models import grounding, Tool
grounded_search_tool = Tool.from_google_search_retrieval(
grounding.GoogleSearchRetrieval()
)
A questo punto, utilizza lo strumento all'interno del modello LangchainAgent:
agent = reasoning_engines.LangchainAgent(
model=model,
tools=[grounded_search_tool],
)
agent.query(input="When is the next total solar eclipse in US?")
La risposta è un dizionario simile al seguente:
{"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."""}
Per maggiori dettagli, visita la pagina Collegamento a terra.
Strumento LangChain
Innanzitutto, installa il pacchetto che definisce lo strumento.
pip install langchain-google-communityImporta il pacchetto e crea lo strumento.
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.",
)
Infine, utilizza lo strumento all'interno del modello LangchainAgent:
agent = reasoning_engines.LangchainAgent(
model=model,
tools=[movie_search_tool],
)
response = agent.query(
input="List some sci-fi movies from the 1990s",
)
Dovrebbe restituire una risposta come
{"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.
[...]
"""}
Per vedere l'esempio completo, visita il blocco note.
Per altri esempi di strumenti disponibili in LangChain, consulta Strumenti di Google.
Estensione Vertex AI
Innanzitutto, importa il pacchetto di estensioni e crea lo strumento
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,
)
Poi utilizza lo strumento all'interno del modello 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},
}
"""
)
Dovrebbe restituire una risposta come
{"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()
```
"""}
Per maggiori dettagli, visita Vertex AI Extensions.
Puoi utilizzare tutti (o un sottoinsieme) gli strumenti che hai creato in 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?")
(Facoltativo) Configurazione dello strumento
Con Gemini, puoi limitare l'utilizzo degli strumenti. Ad esempio: anziché consentire al modello di generare risposte in linguaggio naturale, obbligalo a generare solo chiamate di funzione ("chiamate di funzione forzate").
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",
)
Per maggiori dettagli, visita la pagina Configurazione dello strumento.
Passaggio 3: Memorizzare la cronologia chat
Per monitorare i messaggi di chat e aggiungerli a un database, definisci una funzione get_session_history e passala quando crei l'agente. Questo
deve assumere un valore session_id e restituire un BaseChatMessageHistory
.
session_idè un identificatore della sessione a cui appartengono questi messaggi di input a. In questo modo puoi gestire più conversazioni contemporaneamente.BaseChatMessageHistoryè l'interfaccia per i corsi che possono caricare e salvare di messaggi.
Configura un database
Per un elenco dei fornitori di ChatMessageHistory di Google supportati in LangChain, consulta Memoria.
Firestore (native)
Innanzitutto, segui la documentazione di LangChain per configurare un database e installare il pacchetto.
Poi, definisci una funzione get_session_history come segue:
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,
)
Crea l'agente e passalo come chat_history:
agent = reasoning_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
Bigtable
Innanzitutto, segui la documentazione di LangChain per configurare un database e installare il pacchetto.
Poi, definisci una funzione get_session_history come segue:
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,
)
Crea l'agente e passalo come chat_history:
agent = reasoning_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
Spanner
Innanzitutto, segui la documentazione di LangChain per impostare un database e installare il pacchetto.
A questo punto, definisci una funzione get_session_history come segue:
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,
)
Crea l'agente e passalo come chat_history:
agent = reasoning_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
Quando esegui una query sull'agente, assicurati di passare session_id in modo che l'agente abbia la "memoria" delle domande e delle risposte precedenti:
agent.query(
input="What is the exchange rate from US dollars to Swedish currency?",
config={"configurable": {"session_id": "SESSION_ID"}},
)
Passaggio 4: Personalizzare il modello di prompt
I modelli di prompt aiutano a tradurre input utente in istruzioni per un modello vengono utilizzati per guidare la risposta di un modello, aiutandolo a comprendere il contesto generare output pertinenti e coerenti basati sul linguaggio. Per maggiori dettagli, visita ChatPromptTemplates.
Il modello di prompt predefinito è organizzato in sezioni in sequenza.
| Sezione | Descrizione |
|---|---|
| (Facoltativo) Istruzione di sistema | Istruzioni per l'applicazione dell'agente a tutte le query. |
| (Facoltativo) Cronologia chat | Messaggi corrispondenti alla cronologia chat di una sessione precedente. |
| Input utente | La query dell'utente a cui l'agente deve rispondere. |
| Blocco appunti dell'agente | I messaggi creati dall'agente (ad es. con le chiamate di funzione) mentre svolge le sue attività utilizzano i suoi strumenti ed eseguono deduzioni per formulare una risposta all'utente. |
Il modello di prompt predefinito viene generato se crei l'agente senza specifica il tuo modello di prompt e sarà simile al seguente:
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}"),
])
Puoi eseguire l'override del modello di prompt predefinito con un tuo modello di prompt personalizzato. usalo durante la creazione dell'agente, ad esempio:
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"}},
)
Passaggio 5: Personalizza l'orchestrazione
Tutti i componenti LangChain implementano l'interfaccia eseguibile,
che forniscono schemi di input e output per l'orchestrazione. LangchainAgent
richiede la creazione di un file eseguibile per rispondere alle query. Per impostazione predefinita,
LangchainAgent creerà un elemento eseguibile di questo tipo associando il modello a strumenti
e utilizza AgentExecutor
aggregato in un RunnableWithMessageHistory
se la cronologia chat è abilitata.
Ti consigliamo di personalizzare l'orchestrazione se intendi (i) implementare un agente che esegue un insieme deterministico di passaggi (anziché eseguire ragionamenti aperti) o (ii) chiedere all'agente, in modo simile a ReAct, di annotare ogni passaggio con i motivi per cui lo ha eseguito. Per farlo, devi eseguire l'override dell'eseguibile predefinito durante la creazione di LangchainAgent specificando l'argomento runnable_builder= con una funzione Python della seguente firma:
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,
):
dove
modelcorrisponde al modello di chat restituito damodel_builder(vedi Definire e configurare un modello).toolsemodel_tool_kwargscorrispondono agli strumenti e alle configurazioni da utilizzare (vedi Definire e utilizzare uno strumento).chat_historycorrisponde al database per l'archiviazione dei messaggi di chat (vedi Salva cronologia chat),system_instructionepromptcorrispondono alla configurazione della richiesta (vedi Personalizzare il modello di richiesta),agent_executor_kwargserunnable_kwargssono gli argomenti parola chiave che per personalizzare l'elemento eseguibile da creare.
Ciò offre diverse opzioni per personalizzare la logica di orchestrazione.
ChatModel
Nel caso più semplice, per creare un agente senza orchestrazione, puoi eseguire l'override di runnable_builder per LangchainAgent per restituire direttamente 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
Per eseguire l'override del comportamento di chiamata strumento predefinito con il tuo agente ReAct in base a
il tuo prompt (vedi Personalizzare il modello di prompt),
devi eseguire l'override di runnable_builder per 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,
)
Sintassi LCEL
Per costruire il seguente grafico utilizzando LangChain Expression Language (LCEL),
Input
/ \
Pros Cons
\ /
Summary
devi sostituire runnable_builder con 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
Per creare il grafico seguente utilizzando LangGraph,
Input
/ \
Pros Cons
\ /
Summary
devi sostituire runnable_builder per 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"})