如何强制工具调用代理结构化输出¶
您可能希望您的代理以结构化格式返回其输出。例如，如果代理的输出被其他下游软件使用，您可能希望代理每次被调用时输出都是相同的结构化格式，以确保一致性。
本 Notebook 将介绍两种不同的方法来强制工具调用代理结构化其输出。我们将使用一个基本的 ReAct 代理（一个模型节点和一个工具调用节点），并在最后添加第三个节点用于格式化响应给用户。这两种选项将使用相同的图结构（如下图所示），但在内部机制上有所不同。
选项 1
强制工具调用代理产生结构化输出的第一种方法是将您想要的输出作为额外的工具绑定到 agent 节点供其使用。与基本的 ReAct 代理不同，在这种情况下，agent 节点不是在 tools 和 END 之间进行选择，而是在它调用的特定工具之间进行选择。这种情况下预期的流程是 agent 节点中的 LLM 首先选择行动工具，接收到行动工具的输出后，它会调用响应工具，然后路由到 respond 节点，该节点仅对来自 agent 节点工具调用的参数进行结构化处理。
优点和缺点
这种格式的好处是您只需要一个 LLM，从而节省成本和降低延迟。这种方法的缺点是不能保证单个 LLM 会在您期望它调用时调用正确的工具。我们可以在使用 bind_tools 时通过将 tool_choice 设置为 any 来帮助 LLM，这会强制 LLM 在每一轮选择至少一个工具，但这远非万无一失的策略。此外，另一个缺点是代理可能会调用 多个工具，因此我们需要在路由函数中明确检查这一点（或者如果我们使用 OpenAI，可以设置 parallell_tool_calling=False 以确保一次只调用一个工具）。
选项 2
强制工具调用代理产生结构化输出的第二种方法是使用第二个 LLM（在本例中为 model_with_structured_output）来响应用户。
在这种情况下，您通常会定义一个基本的 ReAct 代理，但 agent 节点不再是在 tools 节点和结束对话之间选择，而是在 tools 节点和 respond 节点之间选择。respond 节点将包含一个使用结构化输出的第二个 LLM，一旦调用，将直接返回给用户。您可以将此方法视为基本 ReAct 在响应用户之前增加了一个额外步骤。
优点和缺点
这种方法的好处是它保证了结构化输出（只要 .with_structured_output 与 LLM 按预期工作）。使用这种方法的缺点是它需要在响应用户之前额外进行一次 LLM 调用，这可能会增加成本和延迟。此外，由于没有向 agent 节点 LLM 提供关于所需输出模式的信息，存在 agent LLM 无法调用生成正确输出模式所需的正确工具的风险。
注意，这两种选项将遵循完全相同的图结构（参见上图），因为它们都是基本 ReAct 架构的精确复制，只是在结束前增加了一个 respond 节点。
设置¶
首先，让我们安装所需的软件包并设置 API 密钥
import getpass
import os
def _set_env(var: str):
if not os.environ.get(var):
os.environ[var] = getpass.getpass(f"{var}: ")
_set_env("ANTHROPIC_API_KEY")
为 LangGraph 开发设置 LangSmith
注册 LangSmith，以便快速发现问题并改进 LangGraph 项目的性能。LangSmith 允许您使用跟踪数据来调试、测试和监控使用 LangGraph 构建的 LLM 应用程序——在此处阅读更多关于如何入门的信息此处。
定义模型、工具和图状态¶
现在我们可以定义我们希望如何结构化输出，定义图状态，以及将要使用的工具和模型。
要使用结构化输出，我们将使用 LangChain 的 with_structured_output 方法，您可以在此处阅读更多相关信息。
在本例中，我们将使用一个用于查询天气的工具，并向用户返回结构化的天气响应。
API 参考: tool | ChatAnthropic
from pydantic import BaseModel, Field
from typing import Literal
from langchain_core.tools import tool
from langchain_anthropic import ChatAnthropic
from langgraph.graph import MessagesState
class WeatherResponse(BaseModel):
"""Respond to the user with this"""
temperature: float = Field(description="The temperature in fahrenheit")
wind_directon: str = Field(
description="The direction of the wind in abbreviated form"
)
wind_speed: float = Field(description="The speed of the wind in km/h")
# Inherit 'messages' key from MessagesState, which is a list of chat messages
class AgentState(MessagesState):
# Final structured response from the agent
final_response: WeatherResponse
@tool
def get_weather(city: Literal["nyc", "sf"]):
"""Use this to get weather information."""
if city == "nyc":
return "It is cloudy in NYC, with 5 mph winds in the North-East direction and a temperature of 70 degrees"
elif city == "sf":
return "It is 75 degrees and sunny in SF, with 3 mph winds in the South-East direction"
else:
raise AssertionError("Unknown city")
tools = [get_weather]
model = ChatAnthropic(model="claude-3-opus-20240229")
model_with_tools = model.bind_tools(tools)
model_with_structured_output = model.with_structured_output(WeatherResponse)
选项 1：将输出绑定为工具¶
现在让我们看看如何使用单个 LLM 的选项。
定义图¶
图的定义与上面非常相似，唯一的区别是我们不再在 response 节点中调用 LLM，而是将 WeatherResponse 工具绑定到已经包含 get_weather 工具的 LLM 上。
API 参考: StateGraph | END | ToolNode
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
tools = [get_weather, WeatherResponse]
# Force the model to use tools by passing tool_choice="any"
model_with_response_tool = model.bind_tools(tools, tool_choice="any")
# Define the function that calls the model
def call_model(state: AgentState):
response = model_with_response_tool.invoke(state["messages"])
# We return a list, because this will get added to the existing list
return {"messages": [response]}
# Define the function that responds to the user
def respond(state: AgentState):
# Construct the final answer from the arguments of the last tool call
weather_tool_call = state["messages"][-1].tool_calls[0]
response = WeatherResponse(**weather_tool_call["args"])
# Since we're using tool calling to return structured output,
# we need to add a tool message corresponding to the WeatherResponse tool call,
# This is due to LLM providers' requirement that AI messages with tool calls
# need to be followed by a tool message for each tool call
tool_message = {
"type": "tool",
"content": "Here is your structured response",
"tool_call_id": weather_tool_call["id"],
}
# We return the final answer
return {"final_response": response, "messages": [tool_message]}
# Define the function that determines whether to continue or not
def should_continue(state: AgentState):
messages = state["messages"]
last_message = messages[-1]
# If there is only one tool call and it is the response tool call we respond to the user
if (
len(last_message.tool_calls) == 1
and last_message.tool_calls[0]["name"] == "WeatherResponse"
):
return "respond"
# Otherwise we will use the tool node again
else:
return "continue"
# Define a new graph
workflow = StateGraph(AgentState)
# Define the two nodes we will cycle between
workflow.add_node("agent", call_model)
workflow.add_node("respond", respond)
workflow.add_node("tools", ToolNode(tools))
# Set the entrypoint as `agent`
# This means that this node is the first one called
workflow.set_entry_point("agent")
# We now add a conditional edge
workflow.add_conditional_edges(
"agent",
should_continue,
{
"continue": "tools",
"respond": "respond",
},
)
workflow.add_edge("tools", "agent")
workflow.add_edge("respond", END)
graph = workflow.compile()
用法¶
现在我们可以运行我们的图来检查它是否按预期工作
answer = graph.invoke(input={"messages": [("human", "what's the weather in SF?")]})[
"final_response"
]
再次，代理返回了一个 WeatherResponse 对象，正如我们所期望的那样。
选项 2：使用 2 个 LLM¶
现在让我们深入探讨如何使用第二个 LLM 来强制实现结构化输出。
定义图¶
现在我们可以定义我们的图
API 参考: StateGraph | END | ToolNode | HumanMessage
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_core.messages import HumanMessage
# Define the function that calls the model
def call_model(state: AgentState):
response = model_with_tools.invoke(state["messages"])
# We return a list, because this will get added to the existing list
return {"messages": [response]}
# Define the function that responds to the user
def respond(state: AgentState):
# We call the model with structured output in order to return the same format to the user every time
# state['messages'][-2] is the last ToolMessage in the convo, which we convert to a HumanMessage for the model to use
# We could also pass the entire chat history, but this saves tokens since all we care to structure is the output of the tool
response = model_with_structured_output.invoke(
[HumanMessage(content=state["messages"][-2].content)]
)
# We return the final answer
return {"final_response": response}
# Define the function that determines whether to continue or not
def should_continue(state: AgentState):
messages = state["messages"]
last_message = messages[-1]
# If there is no function call, then we respond to the user
if not last_message.tool_calls:
return "respond"
# Otherwise if there is, we continue
else:
return "continue"
# Define a new graph
workflow = StateGraph(AgentState)
# Define the two nodes we will cycle between
workflow.add_node("agent", call_model)
workflow.add_node("respond", respond)
workflow.add_node("tools", ToolNode(tools))
# Set the entrypoint as `agent`
# This means that this node is the first one called
workflow.set_entry_point("agent")
# We now add a conditional edge
workflow.add_conditional_edges(
"agent",
should_continue,
{
"continue": "tools",
"respond": "respond",
},
)
workflow.add_edge("tools", "agent")
workflow.add_edge("respond", END)
graph = workflow.compile()
用法¶
现在我们可以调用我们的图来验证输出是否按预期进行了结构化
answer = graph.invoke(input={"messages": [("human", "what's the weather in SF?")]})[
"final_response"
]
如我们所见，代理返回了一个 WeatherResponse 对象，正如我们所期望的那样。现在可以很容易地在一个更复杂的软件栈中使用这个代理，而不必担心代理的输出与栈中下一步骤预期的格式不匹配。