LangChain v1 迁移指南

将此代码库迁移到 LangChain v1（需要 langchain>=1.0.0、langchain-core>=1.0.0 以及 Python 3.10+）。

主要变更：

包命名空间缩减：langchain 包聚焦于智能体、消息、工具、聊天模型和嵌入。旧版链、检索器、索引、hub、诸如 CacheBackedEmbeddings 的嵌入辅助工具以及社区再导出已移至 langchain-classic。安装 langchain-classic，并将这些导入更新为 langchain_classic.*。直接安装服务商包（例如 langchain-openai），而不要依赖 langchain 对社区集成的再导出。
create_react_agent → create_agent：将 from langgraph.prebuilt import create_react_agent 替换为 from langchain.agents import create_agent。将 prompt= 重命名为 system_prompt=。使用 agent.invoke({"messages": [...]}) / agent.stream(...) 调用。优先使用 langchain.agents.AgentState，而非已弃用的 langgraph.prebuilt 智能体状态辅助工具。
Hooks 变为 middleware：用 create_agent middleware（before_model、after_model、@wrap_model_call、@wrap_tool_call）替换 pre_model_hook=、post_model_hook= 和 state_modifier= 自定义。对于人在回路的工具审批，使用来自 langchain.agents.middleware 的 HumanInTheLoopMiddleware(interrupt_on="...")。
结构化输出：保留 response_format=，但使用来自 langchain.agents.structured_output 的 ToolStrategy / ProviderStrategy。诸如 response_format=("please generate ...", Schema) 的提示式输出形式已被移除。
流式节点名称：当按节点名称过滤或匹配流式事件时，将 "agent" 重命名为 "model"。
运行时上下文：通过 invoke / stream 的 context= 参数（以及 create_agent 上的 context_schema=）传递静态上下文，而不仅仅通过 config["configurable"]。
标准内容块：对于服务商无关的内容，优先使用 message.content_blocks。现有的 message.content 仍然有效。

在代码库中搜索 create_react_agent、pre_model_hook、post_model_hook、state_modifier、来自 langgraph.prebuilt 的导入，以及诸如 langchain.chains、langchain.retrievers、langchain.indexes 和 langchain.hub 的旧版 langchain 模块，并应用必要的更改。标记任何无法自动迁移的内容。

本指南概述了 LangChain v1 与先前版本之间的主要变化。

精简的包

langchain 包命名空间在 v1 中已大幅缩减，以聚焦于智能体的基础构建块。精简后的包让核心功能更易被发现和使用。

命名空间

模块	可用内容	说明
`langchain.agents`	`create_agent`, `AgentState`	核心智能体创建功能
`langchain.messages`	消息类型、content blocks、`trim_messages`	从 `langchain-core` 再导出
`langchain.tools`	`@tool`、`BaseTool`、注入辅助工具	从 `langchain-core` 再导出
`langchain.chat_models`	`init_chat_model`、`BaseChatModel`	统一的模型初始化
`langchain.embeddings`	`init_embeddings`、`Embeddings`	嵌入模型

`langchain-classic`

如果你之前使用了 langchain 包中的以下任何内容，你需要安装 langchain-classic 并更新导入：

旧版链（LLMChain、ConversationChain 等）
检索器（例如 MultiQueryRetriever，或来自先前 langchain.retrievers 模块的任何内容）
索引 API
hub 模块（用于以编程方式管理提示词）
嵌入模块（例如 CacheBackedEmbeddings 和社区嵌入）
langchain-community 再导出
其他已弃用的功能

v1（新）v0（旧）

python

# Chains
from langchain_classic.chains import LLMChain

# Retrievers
from langchain_classic.retrievers import ...

# Indexing
from langchain_classic.indexes import ...

# Hub
from langchain_classic import hub

python

# Chains
from langchain_classic.chains import LLMChain

# Retrievers
from langchain.retrievers import ...

# Indexing
from langchain.indexes import ...

# Hub
from langchain import hub

使用以下命令安装：

pipuv

bash

pip install langchain-classic

bash

uv add langchain-classic

迁移到 `create_agent`

在 v1.0 之前，我们建议使用 langgraph.prebuilt.create_react_agent 构建智能体。现在，我们建议你使用 langchain.agents.create_agent 构建智能体。

下表概述了从 create_react_agent 到 create_agent 有哪些功能发生了变化：

章节	TL;DR - 变化内容
导入路径	包从 `langgraph.prebuilt` 移至 `langchain.agents`
提示词	参数重命名为 `system_prompt`，动态提示词使用 middleware
模型前 hook	由带 `before_model` 方法的 middleware 取代
模型后 hook	由带 `after_model` 方法的 middleware 取代
自定义状态	仅支持 `TypedDict`，可通过 `state_schema` 或 middleware 定义
模型	通过 middleware 动态选择，不支持预绑定模型
工具	工具错误处理移至 middleware，使用 `wrap_tool_call`
结构化输出	移除提示式输出，使用 `ToolStrategy`/`ProviderStrategy`
流式节点名称	节点名称从 `"agent"` 改为 `"model"`
运行时上下文	通过 `context` 参数进行依赖注入，而不是 `config["configurable"]`
命名空间	精简以聚焦智能体构建块，旧版代码移至 `langchain-classic`

导入路径

智能体预构建项的导入路径已从 langgraph.prebuilt 改为 langchain.agents。函数名称已从 create_react_agent 改为 create_agent：

python

from langgraph.prebuilt import create_react_agent 
from langchain.agents import create_agent

更多信息请参阅智能体。

提示词

静态提示词重命名

prompt 参数已重命名为 system_prompt：

v1（新）v0（旧）

python

from langchain.agents import create_agent

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[check_weather],
    system_prompt="You are a helpful assistant"
)

python

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=[check_weather],
    prompt="You are a helpful assistant"
)

`SystemMessage` 转字符串

如果在系统提示词中使用 SystemMessage 对象，请提取字符串内容：

v1（新）v0（旧）

python

from langchain.agents import create_agent

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[check_weather],
    system_prompt="You are a helpful assistant"
)

python

from langchain.messages import SystemMessage
from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=[check_weather],
    prompt=SystemMessage(content="You are a helpful assistant")  
)

动态提示词

动态提示词是一种核心的上下文工程模式——它们会根据当前对话状态调整你告诉模型的内容。为此，请使用 @dynamic_prompt 装饰器：

v1（新）v0（旧）

python

from dataclasses import dataclass

from langchain.agents import create_agent
from langchain.agents.middleware import dynamic_prompt, ModelRequest
from langgraph.runtime import Runtime

@dataclass
class Context:  
    user_role: str = "user"

@dynamic_prompt
def dynamic_prompt(request: ModelRequest) -> str:  
    user_role = request.runtime.context.user_role
    base_prompt = "You are a helpful assistant."

    if user_role == "expert":
        prompt = (
            f"{base_prompt} Provide detailed technical responses."
        )
    elif user_role == "beginner":
        prompt = (
            f"{base_prompt} Explain concepts simply and avoid jargon."
        )
    else:
        prompt = base_prompt

    return prompt  

agent = create_agent(
    model="gpt-5.5",
    tools=tools,
    middleware=[dynamic_prompt],  
    context_schema=Context
)

# Use with context
agent.invoke(
    {"messages": [{"role": "user", "content": "Explain async programming"}]},
    context=Context(user_role="expert")
)

python

from dataclasses import dataclass

from langgraph.prebuilt import create_react_agent, AgentState
from langgraph.runtime import get_runtime

@dataclass
class Context:
    user_role: str

def dynamic_prompt(state: AgentState) -> str:
    runtime = get_runtime(Context)  
    user_role = runtime.context.user_role
    base_prompt = "You are a helpful assistant."

    if user_role == "expert":
        return f"{base_prompt} Provide detailed technical responses."
    elif user_role == "beginner":
        return f"{base_prompt} Explain concepts simply and avoid jargon."
    return base_prompt

agent = create_react_agent(
    model="gpt-5.5",
    tools=tools,
    prompt=dynamic_prompt,
    context_schema=Context
)

# Use with context
agent.invoke(
    {"messages": [{"role": "user", "content": "Explain async programming"}]},
    context=Context(user_role="expert")
)

模型前 hook

模型前 hook 现在通过 before_model 方法以 middleware 实现。这种新模式扩展性更强——你可以定义多个 middleware 在模型被调用之前运行，在不同智能体之间复用常见模式。

常见使用场景包括：

总结对话历史
裁剪消息
输入护栏，例如 PII 脱敏

v1 现在内置了摘要 middleware 作为可选方案：

v1（新）v0（旧）

python

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=tools,
    middleware=[
        SummarizationMiddleware(  
            model="claude-sonnet-4-6",  
            trigger={"tokens": 1000}  
        )  
    ]  
)

python

from langgraph.prebuilt import create_react_agent, AgentState

def custom_summarization_function(state: AgentState):
    """Custom logic for message summarization."""
    ...

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=tools,
    pre_model_hook=custom_summarization_function
)

模型后 hook

模型后 hook 现在通过 after_model 方法以 middleware 实现。这种新模式扩展性更强——你可以定义多个 middleware 在模型被调用之后运行，在不同智能体之间复用常见模式。

常见使用场景包括：

人在回路
输出护栏

v1 内置了用于工具调用人在回路审批的 middleware：

v1（新）v0（旧）

python

from langchain.agents import create_agent
from langchain.agents.middleware import HumanInTheLoopMiddleware

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[read_email, send_email],
    middleware=[
        HumanInTheLoopMiddleware(
            interrupt_on={
                "send_email": {
                    "description": "Please review this email before sending",
                    "allowed_decisions": ["approve", "reject"]
                }
            }
        )
    ]
)

python

from langgraph.prebuilt import create_react_agent
from langgraph.prebuilt import AgentState

def custom_human_in_the_loop_hook(state: AgentState):
    """Custom logic for human in the loop approval."""
    ...

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=[read_email, send_email],
    post_model_hook=custom_human_in_the_loop_hook
)

自定义状态

自定义状态通过附加字段扩展默认的智能体状态。你可以通过两种方式定义自定义状态：

通过 create_agent 上的 state_schema - 最适合用于工具中使用的状态
通过 middleware - 最适合由特定 middleware hook 以及附加到该 middleware 的工具所管理的状态

NOTE

通过 middleware 定义自定义状态比通过 create_agent 上的 state_schema 定义更可取，因为它允许你在概念上将状态扩展限定在相关的 middleware 和工具范围内。

state_schema 在 create_agent 上仍然为向后兼容而受支持。

通过 `state_schema` 定义状态

当你的自定义状态需要被工具访问时，请使用 state_schema 参数：

v1（新）v0（旧）

python

from langchain.tools import tool, ToolRuntime
from langchain.agents import create_agent, AgentState  

# Define custom state extending AgentState
class CustomState(AgentState):
    user_name: str

@tool
def greet(
    runtime: ToolRuntime[None, CustomState]
) -> str:
    """Use this to greet the user by name."""
    user_name = runtime.state.get("user_name", "Unknown")  
    return f"Hello {user_name}!"

agent = create_agent(  
    model="claude-sonnet-4-6",
    tools=[greet],
    state_schema=CustomState  
)

python

from typing import Annotated
from langgraph.prebuilt import InjectedState, create_react_agent
from langgraph.prebuilt.chat_agent_executor import AgentState

class CustomState(AgentState):
    user_name: str

def greet(
    state: Annotated[CustomState, InjectedState]
) -> str:
    """Use this to greet the user by name."""
    user_name = state["user_name"]
    return f"Hello {user_name}!"

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=[greet],
    state_schema=CustomState
)

通过 middleware 定义状态

middleware 也可以通过设置 state_schema 属性来定义自定义状态。这有助于在概念上将状态扩展限定在相关的 middleware 和工具范围内。

python

from langchain.agents.middleware import AgentState, AgentMiddleware
from typing_extensions import NotRequired
from typing import Any

class CustomState(AgentState):
    model_call_count: NotRequired[int]

class CallCounterMiddleware(AgentMiddleware[CustomState]):
    state_schema = CustomState  

    def before_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        count = state.get("model_call_count", 0)
        if count > 10:
            return {"jump_to": "end"}
        return None

    def after_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        return {"model_call_count": state.get("model_call_count", 0) + 1}

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[...],
    middleware=[CallCounterMiddleware()]  
)

有关通过 middleware 定义自定义状态的更多详细信息，请参阅 middleware 文档。

状态类型限制

create_agent 的状态 schema 仅支持 TypedDict。不再支持 Pydantic 模型和 dataclass。

v1（新）v0（旧）

python

from langchain.agents import AgentState, create_agent

# AgentState is a TypedDict
class CustomAgentState(AgentState):  
    user_id: str

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=tools,
    state_schema=CustomAgentState  
)

python

from typing_extensions import Annotated

from pydantic import BaseModel
from langgraph.graph import StateGraph
from langgraph.graph.messages import add_messages
from langchain.messages import AnyMessage

class AgentState(BaseModel):  
    messages: Annotated[list[AnyMessage], add_messages]
    user_id: str

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=tools,
    state_schema=AgentState
)

只需继承 langchain.agents.AgentState，而不要继承 BaseModel 或使用 dataclass 装饰。如果你需要执行校验，请在 middleware hook 中处理。

模型

动态模型选择允许你根据运行时上下文（例如任务复杂度、成本约束或用户偏好）选择不同的模型。在 langgraph-prebuilt v0.6 中发布的 create_react_agent 支持通过传给 model 参数的可调用对象进行动态模型和工具选择。

此功能已在 v1 中移植到 middleware 接口。

动态模型选择

v1（新）v0（旧）

python

from langchain.agents import create_agent
from langchain.agents.middleware import (
    AgentMiddleware, ModelRequest
)
from langchain.agents.middleware.types import ModelResponse
from langchain_openai import ChatOpenAI
from typing import Callable

basic_model = ChatOpenAI(model="gpt-5-nano")
advanced_model = ChatOpenAI(model="gpt-5.5")

class DynamicModelMiddleware(AgentMiddleware):

    def wrap_model_call(self, request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]) -> ModelResponse:
        if len(request.state.messages) > self.messages_threshold:
            model = advanced_model
        else:
            model = basic_model
        return handler(request.override(model=model))

    def __init__(self, messages_threshold: int) -> None:
        self.messages_threshold = messages_threshold

agent = create_agent(
    model=basic_model,
    tools=tools,
    middleware=[DynamicModelMiddleware(messages_threshold=10)]
)

python

from langgraph.prebuilt import create_react_agent, AgentState
from langchain_openai import ChatOpenAI

basic_model = ChatOpenAI(model="gpt-5-nano")
advanced_model = ChatOpenAI(model="gpt-5.5")

def select_model(state: AgentState) -> BaseChatModel:
    # use a more advanced model for longer conversations
    if len(state.messages) > 10:
        return advanced_model
    return basic_model

agent = create_react_agent(
    model=select_model,
    tools=tools,
)

预绑定模型

为了更好地支持结构化输出，create_agent 不再接受带有工具或配置的预绑定模型：

python

# No longer supported
model_with_tools = ChatOpenAI().bind_tools([some_tool])
agent = create_agent(model_with_tools, tools=[])

# Use instead
agent = create_agent("gpt-5.4-mini", tools=[some_tool])

NOTE

如果不使用结构化输出，动态模型函数可以返回预绑定模型。

工具

create_agent 的 tools 参数接受以下列表：

LangChain BaseTool 实例（用 @tool 装饰的函数）
具有正确类型提示和 docstring 的可调用对象（函数）
表示内置服务商工具的 dict

该参数将不再接受 ToolNode 实例。

v1（新）v0（旧）

python

from langchain.agents import create_agent

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[check_weather, search_web]
)

python

from langgraph.prebuilt import create_react_agent, ToolNode

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=ToolNode([check_weather, search_web]) 
)

处理工具错误

现在你可以通过实现 wrap_tool_call 方法的 middleware 来配置工具错误的处理。

v1（新）v0（旧）

python

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_tool_call
from langchain.messages import ToolMessage

@wrap_tool_call
def handle_tool_errors(request, handler):
    """Handle tool execution errors with custom messages."""
    try:
        return handler(request)
    except Exception as e:
        # Only handle errors that occur during tool execution due to invalid inputs
        # that pass schema validation but fail at runtime (e.g., invalid SQL syntax).
        # Do NOT handle:
        # - Network failures (use tool retry middleware instead)
        # - Incorrect tool implementation errors (should bubble up)
        # - Schema mismatch errors (already auto-handled by the framework)
        #
        # Return a custom error message to the model
        return ToolMessage(
            content=f"Tool error: Please check your input and try again. ({str(e)})",
            tool_call_id=request.tool_call["id"]
        )

agent = create_agent(
    model="claude-sonnet-4-6",
    tools=[check_weather, search_web],
    middleware=[handle_tool_errors]
)

python

from langgraph.prebuilt import create_react_agent, ToolNode
from langchain.messages import ToolMessage

def handle_tool_error(error: Exception) -> str:
    """Custom error handler function."""
    return f"Tool error: Please check your input and try again. ({str(error)})"

agent = create_react_agent(
    model="claude-sonnet-4-6",
    tools=ToolNode(
        [check_weather, search_web],
        handle_tool_errors=handle_tool_error  
    )
)

结构化输出

节点变更

以前结构化输出是在主智能体之外的一个独立节点中生成的。现在不再是这种情况。我们在主循环中生成结构化输出，从而降低成本并减少延迟。

工具策略与服务商策略

在 v1 中，有两种新的结构化输出策略：

ToolStrategy 使用人工工具调用来生成结构化输出
ProviderStrategy 使用服务商原生的结构化输出生成

v1（新）v0（旧）

python

from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy, ProviderStrategy
from pydantic import BaseModel

class OutputSchema(BaseModel):
    summary: str
    sentiment: str

# Using ToolStrategy
agent = create_agent(
    model="gpt-5.4-mini",
    tools=tools,
    # explicitly using tool strategy
    response_format=ToolStrategy(OutputSchema)  
)

python

from langgraph.prebuilt import create_react_agent
from pydantic import BaseModel

class OutputSchema(BaseModel):
    summary: str
    sentiment: str

agent = create_react_agent(
    model="gpt-5.4-mini",
    tools=tools,
    # using tool strategy by default with no option for provider strategy
    response_format=OutputSchema  
)

# OR

agent = create_react_agent(
    model="gpt-5.4-mini",
    tools=tools,
    # using a custom prompt to instruct the model to generate the output schema
    response_format=("please generate ...", OutputSchema)  
)

移除提示式输出

提示式输出不再通过 response_format 参数支持。与人工工具调用和服务商原生结构化输出等策略相比，提示式输出已被证明并非特别可靠。

流式节点名称重命名

从智能体流式输出事件时，节点名称已从 "agent" 改为 "model"，以更好地反映该节点的用途。

运行时上下文

当你调用智能体时，通常希望传递两类数据：

在整个对话过程中变化的动态状态（例如消息历史）
在对话期间不会改变的静态上下文（例如用户元数据）

在 v1 中，通过为 invoke 和 stream 设置 context 参数来支持静态上下文。

v1（新）v0（旧）

python

from dataclasses import dataclass

from langchain.agents import create_agent

@dataclass
class Context:
    user_id: str
    session_id: str

agent = create_agent(
    model=model,
    tools=tools,
    context_schema=Context  
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Hello"}]},
    context=Context(user_id="123", session_id="abc")  
)

python

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(model, tools)

# Pass context via configurable
result = agent.invoke(
    {"messages": [{"role": "user", "content": "Hello"}]},
    config={  
        "configurable": {  
            "user_id": "123",  
            "session_id": "abc"
        }  
    }  
)

NOTE

旧的 config["configurable"] 模式出于向后兼容仍然有效，但对于新应用或正在迁移到 v1 的应用，建议使用新的 context 参数。

标准内容

在 v1 中，消息获得了与服务商无关的标准内容块。通过 message.content_blocks 访问它们，可在各服务商之间获得一致的类型化视图。对于字符串或服务商原生结构，现有的 message.content 字段保持不变。

变化内容

消息上新增 content_blocks 属性，用于规范化内容
标准化的块形状，记录在消息中
可通过 LC_OUTPUT_VERSION=v1 或 output_version="v1" 选择性地将标准块序列化到 content 中

读取标准化内容

v1（新）v0（旧）

python

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-5-nano")
response = model.invoke("Explain AI")

for block in response.content_blocks:
    if block["type"] == "reasoning":
        print(block.get("reasoning"))
    elif block["type"] == "text":
        print(block.get("text"))

python

# Provider-native formats vary; you needed per-provider handling
response = model.invoke("Explain AI")
for item in response.content:
    if item.get("type") == "reasoning":
        ...  # OpenAI-style reasoning
    elif item.get("type") == "thinking":
        ...  # Anthropic-style thinking
    elif item.get("type") == "text":
        ...  # Text

创建多模态消息

v1（新）v0（旧）

python

from langchain.messages import HumanMessage

message = HumanMessage(content_blocks=[
    {"type": "text", "text": "Describe this image."},
    {"type": "image", "url": "https://example.com/image.jpg"},
])
res = model.invoke([message])

python

from langchain.messages import HumanMessage

message = HumanMessage(content=[
    # Provider-native structure
    {"type": "text", "text": "Describe this image."},
    {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}},
])
res = model.invoke([message])

示例块形状

python

# Text block
text_block = {
    "type": "text",
    "text": "Hello world",
}

# Image block
image_block = {
    "type": "image",
    "url": "https://example.com/image.png",
    "mime_type": "image/png",
}

有关更多详细信息，请参阅内容块参考。

序列化标准内容

默认情况下，标准内容块不会序列化到 content 属性中。如果你需要在 content 属性中访问标准内容块（例如向客户端发送消息时），可以选择将它们序列化到 content 中。

环境变量初始化参数

bash

export LC_OUTPUT_VERSION=v1

python

from langchain.chat_models import init_chat_model

model = init_chat_model(
    "gpt-5-nano",
    output_version="v1",
)

NOTE

了解更多：消息、标准内容块和多模态。

破坏性变更

移除对 Python 3.9 的支持

所有 LangChain 包现在都要求 Python 3.10 或更高版本。Python 3.9 将于 2025 年 10 月达到生命周期终止。

更新聊天模型的返回类型

聊天模型调用的返回类型签名已从 BaseMessage 修正为 AIMessage。实现了 bind_tools 的自定义聊天模型应更新其返回签名：

v1（新）v0（旧）

python

def bind_tools(
        ...
    ) -> Runnable[LanguageModelInput, AIMessage]:

python

def bind_tools(
        ...
    ) -> Runnable[LanguageModelInput, BaseMessage]:

OpenAI responses API 的默认消息格式

在与 Responses API 交互时，langchain-openai 现在默认将响应项存储在消息 content 中。要恢复之前的行为，请将 LC_OUTPUT_VERSION 环境变量设置为 v0，或在实例化 ChatOpenAI 时指定 output_version="v0"。

python

# Enforce previous behavior with output_version flag
model = ChatOpenAI(model="gpt-5.4-mini", output_version="v0")

`langchain-anthropic` 中的默认 `max_tokens`

langchain-anthropic 中的 max_tokens 参数现在根据所选模型默认为更高的值，而不是之前的默认值 1024。如果你依赖旧的默认值，请显式设置 max_tokens=1024。

旧版代码已移至 `langchain-classic`

不属于标准接口和智能体重点范围的现有功能已移至 langchain-classic 包。有关核心 langchain 包中可用内容以及哪些内容移至 langchain-classic 的详细信息，请参阅简化命名空间部分。

移除已弃用的 API

已经被弃用并计划在 1.0 中移除的方法、函数和其他对象已被删除。请查看先前版本的弃用通知以了解替代 API。

Text 属性

在消息对象上使用 .text() 方法时应去掉括号，因为它现在是一个属性：

python

# Property access
text = response.text

# Deprecated method call
text = response.text()

现有的用法模式（即 .text()）将继续可用，但现在会发出警告。方法形式将在 v2 中移除。

从 `AIMessage` 中移除 `example` 参数

example 参数已从 AIMessage 对象中移除。我们建议改用 additional_kwargs 来按需传递额外元数据。

次要变更

AIMessageChunk 对象现在包含一个 chunk_position 属性，其值为 'last' 时表示流中的最后一个块。这使得对消息流的处理更加清晰。如果该块不是最后一个，chunk_position 将为 None。
LanguageModelOutputVar 现在的类型是 AIMessage，而不是 BaseMessage。
合并消息块的逻辑（AIMessageChunk.add）已更新，对合并后块的最终 id 采用了更精细的选择处理。它会优先使用服务商分配的 ID，而不是 LangChain 生成的 ID。
我们现在默认以 utf-8 编码打开文件。
标准测试现在使用多模态内容块。

归档文档

旧文档已归档以供参考：

数据集

创建数据集

运行评估

评估技术

定义评估目标

打分方法

实验配置

多模态评估

分析实验结果

微调

教程

常见数据类型

评估器类型

UI

SDK

框架与集成

改进评估器

反馈

追踪设置

集成

手动埋点

配置与故障排除

项目与环境设置

高级追踪技术

数据与隐私

故障排除指南

查看与管理追踪

批量导出追踪数据

轨迹视图

数据类型参考

监控与告警

在线评估器

自动化

开发你的应用

设置依赖

持久化

能力

助手

运行

并发消息处理

如何构建

鉴权与访问控制

自定义鉴权教程

服务器定制

静态加密

替换内置后端

扩展 HTTP 服务器

请求头与日志

部署指南

参考

配置

参考

提示词

创建与管理提示词

连接模型

上下文中枢

教程

全栈 Web 应用

Agent Server API

控制平面 API

计费与用量

参考

按云服务商起步

用 Terraform 部署

AWS

GCP

Azure

安装实例

配置实例

连接外部服务

平台鉴权与访问控制

管理实例

自托管可观测性

混合部署

脚本

参考

组织