| | from typing import List, Sequence, Union |
| |
|
| | from langchain_core.language_models import BaseLanguageModel |
| | from langchain_core.prompts.chat import 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.format_scratchpad import format_log_to_messages |
| | from langchain.agents.json_chat.prompt import TEMPLATE_TOOL_RESPONSE |
| | from langchain.agents.output_parsers import JSONAgentOutputParser |
| |
|
| |
|
| | def create_json_chat_agent( |
| | llm: BaseLanguageModel, |
| | tools: Sequence[BaseTool], |
| | prompt: ChatPromptTemplate, |
| | stop_sequence: Union[bool, List[str]] = True, |
| | tools_renderer: ToolsRenderer = render_text_description, |
| | template_tool_response: str = TEMPLATE_TOOL_RESPONSE, |
| | ) -> Runnable: |
| | """Create an agent that uses JSON to format its logic, build for Chat Models. |
| | |
| | Args: |
| | llm: LLM to use as the agent. |
| | tools: Tools this agent has access to. |
| | prompt: The prompt to use. See Prompt section below for more. |
| | stop_sequence: bool or list of str. |
| | If True, adds a stop token of "Observation:" 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. |
| | tools_renderer: This controls how the tools are converted into a string and |
| | then passed into the LLM. Default is `render_text_description`. |
| | template_tool_response: Template prompt that uses the tool response (observation) |
| | to make the LLM generate the next action to take. |
| | Default is TEMPLATE_TOOL_RESPONSE. |
| | |
| | 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. |
| | |
| | Raises: |
| | ValueError: If the prompt is missing required variables. |
| | ValueError: If the template_tool_response is missing |
| | the required variable 'observation'. |
| | |
| | Example: |
| | |
| | .. code-block:: python |
| | |
| | from langchain import hub |
| | from langchain_community.chat_models import ChatOpenAI |
| | from langchain.agents import AgentExecutor, create_json_chat_agent |
| | |
| | prompt = hub.pull("hwchase17/react-chat-json") |
| | model = ChatOpenAI() |
| | tools = ... |
| | |
| | agent = create_json_chat_agent(model, tools, prompt) |
| | agent_executor = AgentExecutor(agent=agent, tools=tools) |
| | |
| | agent_executor.invoke({"input": "hi"}) |
| | |
| | # Using with chat history |
| | from langchain_core.messages import AIMessage, HumanMessage |
| | agent_executor.invoke( |
| | { |
| | "input": "what's my name?", |
| | "chat_history": [ |
| | HumanMessage(content="hi! my name is bob"), |
| | AIMessage(content="Hello Bob! How can I assist you today?"), |
| | ], |
| | } |
| | ) |
| | |
| | Prompt: |
| | |
| | The prompt must have input keys: |
| | * `tools`: contains descriptions and arguments for each tool. |
| | * `tool_names`: contains all tool names. |
| | * `agent_scratchpad`: must be a MessagesPlaceholder. Contains previous agent actions and tool outputs as messages. |
| | |
| | Here's an example: |
| | |
| | .. code-block:: python |
| | |
| | from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder |
| | |
| | system = '''Assistant is a large language model trained by OpenAI. |
| | |
| | Assistant is designed to be able to assist with a wide range of tasks, from answering \ |
| | simple questions to providing in-depth explanations and discussions on a wide range of \ |
| | topics. As a language model, Assistant is able to generate human-like text based on \ |
| | the input it receives, allowing it to engage in natural-sounding conversations and \ |
| | provide responses that are coherent and relevant to the topic at hand. |
| | |
| | Assistant is constantly learning and improving, and its capabilities are constantly \ |
| | evolving. It is able to process and understand large amounts of text, and can use this \ |
| | knowledge to provide accurate and informative responses to a wide range of questions. \ |
| | Additionally, Assistant is able to generate its own text based on the input it \ |
| | receives, allowing it to engage in discussions and provide explanations and \ |
| | descriptions on a wide range of topics. |
| | |
| | Overall, Assistant is a powerful system that can help with a wide range of tasks \ |
| | and provide valuable insights and information on a wide range of topics. Whether \ |
| | you need help with a specific question or just want to have a conversation about \ |
| | a particular topic, Assistant is here to assist.''' |
| | |
| | human = '''TOOLS |
| | ------ |
| | Assistant can ask the user to use tools to look up information that may be helpful in \ |
| | answering the users original question. The tools the human can use are: |
| | |
| | {tools} |
| | |
| | RESPONSE FORMAT INSTRUCTIONS |
| | ---------------------------- |
| | |
| | When responding to me, please output a response in one of two formats: |
| | |
| | **Option 1:** |
| | Use this if you want the human to use a tool. |
| | Markdown code snippet formatted in the following schema: |
| | |
| | ```json |
| | {{ |
| | "action": string, \\ The action to take. Must be one of {tool_names} |
| | "action_input": string \\ The input to the action |
| | }} |
| | ``` |
| | |
| | **Option #2:** |
| | Use this if you want to respond directly to the human. Markdown code snippet formatted \ |
| | in the following schema: |
| | |
| | ```json |
| | {{ |
| | "action": "Final Answer", |
| | "action_input": string \\ You should put what you want to return to use here |
| | }} |
| | ``` |
| | |
| | USER'S INPUT |
| | -------------------- |
| | Here is the user's input (remember to respond with a markdown code snippet of a json \ |
| | blob with a single action, and NOTHING else): |
| | |
| | {input}''' |
| | |
| | prompt = ChatPromptTemplate.from_messages( |
| | [ |
| | ("system", system), |
| | MessagesPlaceholder("chat_history", optional=True), |
| | ("human", human), |
| | MessagesPlaceholder("agent_scratchpad"), |
| | ] |
| | ) |
| | """ |
| | missing_vars = {"tools", "tool_names", "agent_scratchpad"}.difference( |
| | prompt.input_variables + list(prompt.partial_variables) |
| | ) |
| | if missing_vars: |
| | raise ValueError(f"Prompt missing required variables: {missing_vars}") |
| |
|
| | if "{observation}" not in template_tool_response: |
| | raise ValueError( |
| | "Template tool response missing required variable 'observation'" |
| | ) |
| |
|
| | prompt = prompt.partial( |
| | tools=tools_renderer(list(tools)), |
| | tool_names=", ".join([t.name for t in tools]), |
| | ) |
| | if stop_sequence: |
| | stop = ["\nObservation"] if stop_sequence is True else stop_sequence |
| | llm_to_use = llm.bind(stop=stop) |
| | else: |
| | llm_to_use = llm |
| |
|
| | agent = ( |
| | RunnablePassthrough.assign( |
| | agent_scratchpad=lambda x: format_log_to_messages( |
| | x["intermediate_steps"], template_tool_response=template_tool_response |
| | ) |
| | ) |
| | | prompt |
| | | llm_to_use |
| | | JSONAgentOutputParser() |
| | ) |
| | return agent |
| |
|
