|
|
from typing import Any, List, Sequence, Tuple, Union |
|
|
|
|
|
from langchain_core._api import deprecated |
|
|
from langchain_core.agents import AgentAction, AgentFinish |
|
|
from langchain_core.callbacks import Callbacks |
|
|
from langchain_core.language_models import BaseLanguageModel |
|
|
from langchain_core.prompts.base import BasePromptTemplate |
|
|
from langchain_core.prompts.chat import AIMessagePromptTemplate, ChatPromptTemplate |
|
|
from langchain_core.runnables import Runnable, RunnablePassthrough |
|
|
from langchain_core.tools import BaseTool |
|
|
from langchain_core.tools.render import ToolsRenderer, render_text_description |
|
|
|
|
|
from langchain.agents.agent import BaseSingleActionAgent |
|
|
from langchain.agents.format_scratchpad import format_xml |
|
|
from langchain.agents.output_parsers import XMLAgentOutputParser |
|
|
from langchain.agents.xml.prompt import agent_instructions |
|
|
from langchain.chains.llm import LLMChain |
|
|
|
|
|
|
|
|
@deprecated("0.1.0", alternative="create_xml_agent", removal="1.0") |
|
|
class XMLAgent(BaseSingleActionAgent): |
|
|
"""Agent that uses XML tags. |
|
|
|
|
|
Args: |
|
|
tools: list of tools the agent can choose from |
|
|
llm_chain: The LLMChain to call to predict the next action |
|
|
|
|
|
Examples: |
|
|
|
|
|
.. code-block:: python |
|
|
|
|
|
from langchain.agents import XMLAgent |
|
|
from langchain |
|
|
|
|
|
tools = ... |
|
|
model = |
|
|
|
|
|
|
|
|
""" |
|
|
|
|
|
tools: List[BaseTool] |
|
|
"""List of tools this agent has access to.""" |
|
|
llm_chain: LLMChain |
|
|
"""Chain to use to predict action.""" |
|
|
|
|
|
@property |
|
|
def input_keys(self) -> List[str]: |
|
|
return ["input"] |
|
|
|
|
|
@staticmethod |
|
|
def get_default_prompt() -> ChatPromptTemplate: |
|
|
base_prompt = ChatPromptTemplate.from_template(agent_instructions) |
|
|
return base_prompt + AIMessagePromptTemplate.from_template( |
|
|
"{intermediate_steps}" |
|
|
) |
|
|
|
|
|
@staticmethod |
|
|
def get_default_output_parser() -> XMLAgentOutputParser: |
|
|
return XMLAgentOutputParser() |
|
|
|
|
|
def plan( |
|
|
self, |
|
|
intermediate_steps: List[Tuple[AgentAction, str]], |
|
|
callbacks: Callbacks = None, |
|
|
**kwargs: Any, |
|
|
) -> Union[AgentAction, AgentFinish]: |
|
|
log = "" |
|
|
for action, observation in intermediate_steps: |
|
|
log += ( |
|
|
f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" |
|
|
f"</tool_input><observation>{observation}</observation>" |
|
|
) |
|
|
tools = "" |
|
|
for tool in self.tools: |
|
|
tools += f"{tool.name}: {tool.description}\n" |
|
|
inputs = { |
|
|
"intermediate_steps": log, |
|
|
"tools": tools, |
|
|
"question": kwargs["input"], |
|
|
"stop": ["</tool_input>", "</final_answer>"], |
|
|
} |
|
|
response = self.llm_chain(inputs, callbacks=callbacks) |
|
|
return response[self.llm_chain.output_key] |
|
|
|
|
|
async def aplan( |
|
|
self, |
|
|
intermediate_steps: List[Tuple[AgentAction, str]], |
|
|
callbacks: Callbacks = None, |
|
|
**kwargs: Any, |
|
|
) -> Union[AgentAction, AgentFinish]: |
|
|
log = "" |
|
|
for action, observation in intermediate_steps: |
|
|
log += ( |
|
|
f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" |
|
|
f"</tool_input><observation>{observation}</observation>" |
|
|
) |
|
|
tools = "" |
|
|
for tool in self.tools: |
|
|
tools += f"{tool.name}: {tool.description}\n" |
|
|
inputs = { |
|
|
"intermediate_steps": log, |
|
|
"tools": tools, |
|
|
"question": kwargs["input"], |
|
|
"stop": ["</tool_input>", "</final_answer>"], |
|
|
} |
|
|
response = await self.llm_chain.acall(inputs, callbacks=callbacks) |
|
|
return response[self.llm_chain.output_key] |
|
|
|
|
|
|
|
|
def create_xml_agent( |
|
|
llm: BaseLanguageModel, |
|
|
tools: Sequence[BaseTool], |
|
|
prompt: BasePromptTemplate, |
|
|
tools_renderer: ToolsRenderer = render_text_description, |
|
|
*, |
|
|
stop_sequence: Union[bool, List[str]] = True, |
|
|
) -> Runnable: |
|
|
"""Create an agent that uses XML to format its logic. |
|
|
|
|
|
Args: |
|
|
llm: LLM to use as the agent. |
|
|
tools: Tools this agent has access to. |
|
|
prompt: The prompt to use, must have input keys |
|
|
`tools`: contains descriptions for each tool. |
|
|
`agent_scratchpad`: contains previous agent actions and tool outputs. |
|
|
tools_renderer: This controls how the tools are converted into a string and |
|
|
then passed into the LLM. Default is `render_text_description`. |
|
|
stop_sequence: bool or list of str. |
|
|
If True, adds a stop token of "</tool_input>" to avoid hallucinates. |
|
|
If False, does not add a stop token. |
|
|
If a list of str, uses the provided list as the stop tokens. |
|
|
|
|
|
Default is True. You may to set this to False if the LLM you are using |
|
|
does not support stop sequences. |
|
|
|
|
|
Returns: |
|
|
A Runnable sequence representing an agent. It takes as input all the same input |
|
|
variables as the prompt passed in does. It returns as output either an |
|
|
AgentAction or AgentFinish. |
|
|
|
|
|
Example: |
|
|
|
|
|
.. code-block:: python |
|
|
|
|
|
from langchain import hub |
|
|
from langchain_community.chat_models import ChatAnthropic |
|
|
from langchain.agents import AgentExecutor, create_xml_agent |
|
|
|
|
|
prompt = hub.pull("hwchase17/xml-agent-convo") |
|
|
model = ChatAnthropic(model="claude-3-haiku-20240307") |
|
|
tools = ... |
|
|
|
|
|
agent = create_xml_agent(model, tools, prompt) |
|
|
agent_executor = AgentExecutor(agent=agent, tools=tools) |
|
|
|
|
|
agent_executor.invoke({"input": "hi"}) |
|
|
|
|
|
# Use with chat history |
|
|
from langchain_core.messages import AIMessage, HumanMessage |
|
|
agent_executor.invoke( |
|
|
{ |
|
|
"input": "what's my name?", |
|
|
# Notice that chat_history is a string |
|
|
# since this prompt is aimed at LLMs, not chat models |
|
|
"chat_history": "Human: My name is Bob\\nAI: Hello Bob!", |
|
|
} |
|
|
) |
|
|
|
|
|
Prompt: |
|
|
|
|
|
The prompt must have input keys: |
|
|
* `tools`: contains descriptions for each tool. |
|
|
* `agent_scratchpad`: contains previous agent actions and tool outputs as an XML string. |
|
|
|
|
|
Here's an example: |
|
|
|
|
|
.. code-block:: python |
|
|
|
|
|
from langchain_core.prompts import PromptTemplate |
|
|
|
|
|
template = '''You are a helpful assistant. Help the user answer any questions. |
|
|
|
|
|
You have access to the following tools: |
|
|
|
|
|
{tools} |
|
|
|
|
|
In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags. You will then get back a response in the form <observation></observation> |
|
|
For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond: |
|
|
|
|
|
<tool>search</tool><tool_input>weather in SF</tool_input> |
|
|
<observation>64 degrees</observation> |
|
|
|
|
|
When you are done, respond with a final answer between <final_answer></final_answer>. For example: |
|
|
|
|
|
<final_answer>The weather in SF is 64 degrees</final_answer> |
|
|
|
|
|
Begin! |
|
|
|
|
|
Previous Conversation: |
|
|
{chat_history} |
|
|
|
|
|
Question: {input} |
|
|
{agent_scratchpad}''' |
|
|
prompt = PromptTemplate.from_template(template) |
|
|
""" |
|
|
missing_vars = {"tools", "agent_scratchpad"}.difference( |
|
|
prompt.input_variables + list(prompt.partial_variables) |
|
|
) |
|
|
if missing_vars: |
|
|
raise ValueError(f"Prompt missing required variables: {missing_vars}") |
|
|
|
|
|
prompt = prompt.partial( |
|
|
tools=tools_renderer(list(tools)), |
|
|
) |
|
|
|
|
|
if stop_sequence: |
|
|
stop = ["</tool_input>"] if stop_sequence is True else stop_sequence |
|
|
llm_with_stop = llm.bind(stop=stop) |
|
|
else: |
|
|
llm_with_stop = llm |
|
|
|
|
|
agent = ( |
|
|
RunnablePassthrough.assign( |
|
|
agent_scratchpad=lambda x: format_xml(x["intermediate_steps"]), |
|
|
) |
|
|
| prompt |
|
|
| llm_with_stop |
|
|
| XMLAgentOutputParser() |
|
|
) |
|
|
return agent |
|
|
|
