跳到主要内容

文档索引

在以下地址获取完整的文档索引:https://docs.langchain.org.cn/llms.txt

在进一步探索之前,请使用此文件发现所有可用页面。

工具扩展了智能体的能力,使其能够获取实时数据、执行代码、查询外部数据库并在现实世界中采取行动。 在底层,工具是可调用函数,具有明确定义的输入和输出,并传递给聊天模型。模型根据对话上下文决定何时调用工具以及提供哪些输入参数。
有关模型如何处理工具调用的详细信息,请参阅工具调用

创建工具

基本工具定义

创建工具最简单的方法是使用@tool装饰器。默认情况下,函数的文档字符串会成为工具的描述,帮助模型理解何时使用它。
from langchain.tools import tool

@tool
def search_database(query: str, limit: int = 10) -> str:
    """Search the customer database for records matching the query.

    Args:
        query: Search terms to look for
        limit: Maximum number of results to return
    """
    return f"Found {limit} results for '{query}'"
类型提示是必需的,因为它们定义了工具的输入模式。文档字符串应信息丰富且简洁,以帮助模型理解工具的用途。
服务器端工具使用:某些聊天模型具有内置工具(网页搜索、代码解释器),这些工具在服务器端执行。有关详细信息,请参阅服务器端工具使用
工具名称首选使用snake_case(例如,web_search而不是Web Search)。一些模型提供商对包含空格或特殊字符的名称存在问题或会报错。坚持使用字母数字字符、下划线和连字符有助于提高跨提供商的兼容性。

自定义工具属性

自定义工具名称

默认情况下,工具名称来自函数名。当您需要更具描述性的名称时,可以覆盖它。
@tool("web_search")  # Custom name
def search(query: str) -> str:
    """Search the web for information."""
    return f"Results for: {query}"

print(search.name)  # web_search

自定义工具描述

覆盖自动生成的工具描述,以提供更清晰的模型指导。
@tool("calculator", description="Performs arithmetic calculations. Use this for any math problems.")
def calc(expression: str) -> str:
    """Evaluate mathematical expressions."""
    return str(eval(expression))

高级模式定义

使用 Pydantic 模型或 JSON 模式定义复杂输入。
from pydantic import BaseModel, Field
from typing import Literal

class WeatherInput(BaseModel):
    """Input for weather queries."""
    location: str = Field(description="City name or coordinates")
    units: Literal["celsius", "fahrenheit"] = Field(
        default="celsius",
        description="Temperature unit preference"
    )
    include_forecast: bool = Field(
        default=False,
        description="Include 5-day forecast"
    )

@tool(args_schema=WeatherInput)
def get_weather(location: str, units: str = "celsius", include_forecast: bool = False) -> str:
    """Get current weather and optional forecast."""
    temp = 22 if units == "celsius" else 72
    result = f"Current weather in {location}: {temp} degrees {units[0].upper()}"
    if include_forecast:
        result += "\nNext 5 days: Sunny"
    return result

保留参数名称

以下参数名称是保留的,不能用作工具参数。使用这些名称将导致运行时错误。
参数名称目的
配置保留用于内部将RunnableConfig传递给工具。
runtime保留用于ToolRuntime参数(访问状态、上下文、存储)。
要访问运行时信息,请使用ToolRuntime参数,而不是将您自己的参数命名为configruntime

访问上下文

当工具可以访问运行时信息(如对话历史、用户数据和持久记忆)时,它们功能最强大。本节介绍如何从工具内部访问和更新这些信息。 工具可以通过ToolRuntime参数访问运行时信息,该参数提供:
组件描述用例
状态短期记忆 - 存在于当前对话期间的可变数据(消息、计数器、自定义字段)访问对话历史,跟踪工具调用计数。
上下文在调用时传递的不可变配置(用户 ID、会话信息)根据用户身份个性化响应。
存储长期记忆 - 跨对话持久存在的数据。保存用户偏好,维护知识库。
流写入器在工具执行期间发出实时更新。显示长时间运行操作的进度。
执行信息当前执行的身份和重试信息(线程 ID、运行 ID、尝试次数)。访问线程/运行 ID,根据重试状态调整行为。
服务器信息在 LangGraph Server 上运行时,服务器特定的元数据(助理 ID、图 ID、已认证用户)。访问助理 ID、图 ID 或已认证用户信息。
配置RunnableConfig用于执行访问回调、标签和元数据。
工具调用 ID当前工具调用的唯一标识符。关联日志和模型调用的工具调用。

短期记忆(状态)

状态代表在对话期间存在的短期记忆。它包括消息历史记录以及您在图状态中定义的任何自定义字段。
runtime: ToolRuntime添加到您的工具签名中以访问状态。此参数会自动注入并对 LLM 隐藏——它不会出现在工具的模式中。

访问状态

工具可以使用runtime.state访问当前对话状态。
from langchain.tools import tool, ToolRuntime
from langchain.messages import HumanMessage

@tool
def get_last_user_message(runtime: ToolRuntime) -> str:
    """Get the most recent message from the user."""
    messages = runtime.state["messages"]

    # Find the last human message
    for message in reversed(messages):
        if isinstance(message, HumanMessage):
            return message.content

    return "No user messages found"

# Access custom state fields
@tool
def get_user_preference(
    pref_name: str,
    runtime: ToolRuntime
) -> str:
    """Get a user preference value."""
    preferences = runtime.state.get("user_preferences", {})
    return preferences.get(pref_name, "Not set")
runtime参数对模型是隐藏的。对于上面的示例,模型在工具模式中只看到pref_name

更新状态

使用Command来更新智能体的状态。这对于需要更新自定义状态字段的工具非常有用。在更新中包含一个ToolMessage,以便模型可以看到工具调用的结果。
from langchain.agents import AgentState
from langchain.messages import ToolMessage
from langchain.tools import ToolRuntime, tool
from langgraph.types import Command


class CustomState(AgentState):
    user_name: str


@tool
def set_user_name(new_name: str, runtime: ToolRuntime[None, CustomState]) -> Command:
    """Set the user's name in the conversation state."""
    return Command(
        update={
            "user_name": new_name,
            "messages": [
                ToolMessage(
                    content=f"User name set to {new_name}.",
                    tool_call_id=runtime.tool_call_id,
                )
            ],
        }
    )
当工具更新状态变量时,请考虑为这些字段定义一个reducer。由于 LLM 可以并行调用多个工具,reducer 决定了当同一个状态字段被并发工具调用更新时如何解决冲突。

上下文

上下文提供在调用时传递的不可变配置数据。它可用于用户 ID、会话详细信息或在对话期间不应更改的应用程序特定设置。 通过runtime.context访问上下文:
from dataclasses import dataclass
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent
from langchain.tools import tool, ToolRuntime


USER_DATABASE = {
    "user123": {
        "name": "Alice Johnson",
        "account_type": "Premium",
        "balance": 5000,
        "email": "alice@example.com"
    },
    "user456": {
        "name": "Bob Smith",
        "account_type": "Standard",
        "balance": 1200,
        "email": "bob@example.com"
    }
}

@dataclass
class UserContext:
    user_id: str

@tool
def get_account_info(runtime: ToolRuntime[UserContext]) -> str:
    """Get the current user's account information."""
    user_id = runtime.context.user_id

    if user_id in USER_DATABASE:
        user = USER_DATABASE[user_id]
        return f"Account holder: {user['name']}\nType: {user['account_type']}\nBalance: ${user['balance']}"
    return "User not found"

model = ChatOpenAI(model="gpt-5.4")
agent = create_agent(
    model,
    tools=[get_account_info],
    context_schema=UserContext,
    system_prompt="You are a financial assistant."
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's my current balance?"}]},
    context=UserContext(user_id="user123")
)

长期记忆(存储)

BaseStore提供跨对话持久存在的存储。与状态(短期记忆)不同,保存到存储中的数据在未来的会话中仍然可用。 通过runtime.store访问存储。存储使用命名空间/键模式来组织数据:
对于生产部署,请使用像PostgresStore这样的持久存储实现,而不是InMemoryStore。有关设置详细信息,请参阅内存文档
from typing import Any
from langgraph.store.memory import InMemoryStore
from langchain.agents import create_agent
from langchain.tools import tool, ToolRuntime
from langchain_openai import ChatOpenAI

# Access memory
@tool
def get_user_info(user_id: str, runtime: ToolRuntime) -> str:
    """Look up user info."""
    store = runtime.store
    user_info = store.get(("users",), user_id)
    return str(user_info.value) if user_info else "Unknown user"

# Update memory
@tool
def save_user_info(user_id: str, user_info: dict[str, Any], runtime: ToolRuntime) -> str:
    """Save user info."""
    store = runtime.store
    store.put(("users",), user_id, user_info)
    return "Successfully saved user info."

model = ChatOpenAI(model="gpt-5.4")

store = InMemoryStore()
agent = create_agent(
    model,
    tools=[get_user_info, save_user_info],
    store=store
)

# First session: save user info
agent.invoke({
    "messages": [{"role": "user", "content": "Save the following user: userid: abc123, name: Foo, age: 25, email: foo@langchain.dev"}]
})

# Second session: get user info
agent.invoke({
    "messages": [{"role": "user", "content": "Get user info for user with id 'abc123'"}]
})
# Here is the user info for user with ID "abc123":
# - Name: Foo
# - Age: 25
# - Email: foo@langchain.dev

流写入器

在执行期间从工具流式传输实时更新。这对于在长时间运行的操作期间向用户提供进度反馈非常有用。 使用runtime.stream_writer发出自定义更新:
from langchain.tools import tool, ToolRuntime

@tool
def get_weather(city: str, runtime: ToolRuntime) -> str:
    """Get weather for a given city."""
    writer = runtime.stream_writer

    # Stream custom updates as the tool executes
    writer(f"Looking up data for city: {city}")
    writer(f"Acquired data for city: {city}")

    return f"It's always sunny in {city}!"
如果在工具内部使用runtime.stream_writer,则必须在 LangGraph 执行上下文内调用该工具。有关更多详细信息,请参阅流式传输

执行信息

通过runtime.execution_info从工具内部访问线程 ID、运行 ID 和重试状态。
from langchain.tools import tool, ToolRuntime

@tool
def log_execution_context(runtime: ToolRuntime) -> str:
    """Log execution identity information."""
    info = runtime.execution_info
    print(f"Thread: {info.thread_id}, Run: {info.run_id}")
    print(f"Attempt: {info.node_attempt}")
    return "done"
需要deepagents>=0.5.0(或langgraph>=1.1.5)。

服务器信息

当您的工具在 LangGraph Server 上运行时,通过runtime.server_info访问助理 ID、图 ID 和已认证用户。
from langchain.tools import tool, ToolRuntime

@tool
def get_assistant_scoped_data(runtime: ToolRuntime) -> str:
    """Fetch data scoped to the current assistant."""
    server = runtime.server_info
    if server is not None:
        print(f"Assistant: {server.assistant_id}, Graph: {server.graph_id}")
        if server.user is not None:
            print(f"User: {server.user.identity}")
    return "done"
当工具未在 LangGraph Server 上运行时(例如,在本地开发或测试期间),server_infoNone
需要deepagents>=0.5.0(或langgraph>=1.1.5)。

工具节点

ToolNode是一个预构建节点,用于在 LangGraph 工作流中执行工具。它自动处理并行工具执行、错误处理和状态注入。
对于需要对工具执行模式进行精细控制的自定义工作流,请使用ToolNode而不是create_agent。它是驱动智能体工具执行的构建块。

基本用法

from langchain.tools import tool
from langgraph.prebuilt import ToolNode
from langgraph.graph import StateGraph, MessagesState, START, END

@tool
def search(query: str) -> str:
    """Search for information."""
    return f"Results for: {query}"

@tool
def calculator(expression: str) -> str:
    """Evaluate a math expression."""
    return str(eval(expression))

# Create the ToolNode with your tools
tool_node = ToolNode([search, calculator])

# Use in a graph
builder = StateGraph(MessagesState)
builder.add_node("tools", tool_node)
# ... add other nodes and edges

工具返回值

您可以为工具选择不同的返回值。
  • 返回一个string以获取人类可读的结果。
  • 返回一个object以获取模型应解析的结构化结果。
  • 当您需要写入状态时,返回一个带有可选消息的Command

返回字符串

当工具应提供纯文本供模型读取并在其下一个响应中使用时,返回字符串。
from langchain.tools import tool


@tool
def get_weather(city: str) -> str:
    """Get weather for a city."""
    return f"It is currently sunny in {city}."
行为
  • 返回值被转换为ToolMessage
  • 模型会看到该文本并决定下一步做什么。
  • 除非模型或另一个工具稍后更改,否则智能体状态字段不会更改。
当结果是自然的人类可读文本时使用此方法。

返回对象

当您的工具生成模型应检查的结构化数据时,返回一个对象(例如,一个dict)。
from langchain.tools import tool


@tool
def get_weather_data(city: str) -> dict:
    """Get structured weather data for a city."""
    return {
        "city": city,
        "temperature_c": 22,
        "conditions": "sunny",
    }
行为
  • 该对象被序列化并作为工具输出返回。
  • 模型可以读取特定字段并对其进行推理。
  • 与字符串返回一样,这不会直接更新图状态。
当后续推理受益于明确的字段而不是自由格式文本时使用此方法。

返回命令

当工具需要更新图状态时(例如,设置用户偏好或应用程序状态),返回一个Command。您可以返回一个带有或不带ToolMessageCommand。如果模型需要看到工具成功(例如,确认偏好更改),请在更新中包含一个ToolMessage,并使用runtime.tool_call_id作为tool_call_id参数。
from langchain.messages import ToolMessage
from langchain.tools import ToolRuntime, tool
from langgraph.types import Command


@tool
def set_language(language: str, runtime: ToolRuntime) -> Command:
    """Set the preferred response language."""
    return Command(
        update={
            "preferred_language": language,
            "messages": [
                ToolMessage(
                    content=f"Language set to {language}.",
                    tool_call_id=runtime.tool_call_id,
                )
            ],
        }
    )
行为
  • 命令使用update更新状态。
  • 更新后的状态可供同一运行中的后续步骤使用。
  • 对可能被并行工具调用更新的字段使用 reducer。
当工具不仅返回数据,还修改智能体状态时使用此方法。

错误处理

配置工具错误的 ABL。有关所有选项,请参阅ToolNode API 参考。
from langgraph.prebuilt import ToolNode

# Default: catch invocation errors, re-raise execution errors
tool_node = ToolNode(tools)

# Catch all errors and return error message to LLM
tool_node = ToolNode(tools, handle_tool_errors=True)

# Custom error message
tool_node = ToolNode(tools, handle_tool_errors="Something went wrong, please try again.")

# Custom error handler
def handle_error(e: ValueError) -> str:
    return f"Invalid input: {e}"

tool_node = ToolNode(tools, handle_tool_errors=handle_error)

# Only catch specific exception types
tool_node = ToolNode(tools, handle_tool_errors=(ValueError, TypeError))

使用 tools_condition 进行路由

使用tools_condition根据 LLM 是否进行了工具调用进行条件路由。
from langgraph.prebuilt import ToolNode, tools_condition
from langgraph.graph import StateGraph, MessagesState, START, END

builder = StateGraph(MessagesState)
builder.add_node("llm", call_llm)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "llm")
builder.add_conditional_edges("llm", tools_condition)  # Routes to "tools" or END
builder.add_edge("tools", "llm")

graph = builder.compile()

状态注入

工具可以通过ToolRuntime访问当前的图状态。
from langchain.tools import tool, ToolRuntime
from langgraph.prebuilt import ToolNode

@tool
def get_message_count(runtime: ToolRuntime) -> str:
    """Get the number of messages in the conversation."""
    messages = runtime.state["messages"]
    return f"There are {len(messages)} messages."

tool_node = ToolNode([get_message_count])
有关从工具访问状态、上下文和长期记忆的更多详细信息,请参阅访问上下文

预构建工具

LangChain 提供了大量预构建的工具和工具包,用于网页搜索、代码解释、数据库访问等常见任务。这些即用型工具可以直接集成到您的智能体中,无需编写自定义代码。 有关按类别组织的可用工具的完整列表,请参阅工具和工具包集成页面。

服务器端工具使用

一些聊天模型具有内置工具,由模型提供商在服务器端执行。这包括网页搜索和代码解释器等功能,无需您定义或托管工具逻辑。 有关启用和使用这些内置工具的详细信息,请参阅各个聊天模型集成页面工具调用文档
© . This site is unofficial and not affiliated with LangChain, Inc.