|
|
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 |
|
|
|
