langchain在今年10月20号发布了v1版本，langchain框架从2022年开始，主要专注于做大模型应用开发，历时三年发展发布了1.0版本，1.0版本的变化还是比较大的，甚至对一些主要的API都做了变动，不过其本质上还都是为了简化智能体的开发，langchain v1围绕三个核心改善简化了框架：
● create_agent：新的构建agent的标准接口，替换旧的langgraph.prebuilt.create_react_agent
● 标准的content blocks：一个新的 content_blocks 属性，提供了跨不同提供商对现代大语言模型（LLM）功能的统一访问。
● 简化命名空间：langchain命名空间已被精简，专注于为agent提供必要的构建模块，而旧版功能则移至langchain-classic。

create_agent

create_agent 是 LangChain 1.0 中构建代理的标准方式。它提供了比 langgraph.prebuilt.create_react_agent 更简单的接口，同时通过使用中间件(middleware)提供了更大的自定义潜力。

from langchain.agents import create_agent

agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=[search_web, analyze_data, send_email],
    system_prompt="You are a helpful research assistant."
)

result = agent.invoke({
    "messages": [
        {"role": "user", "content": "Research AI safety trends"}
    ]
})

在底层实现中，create_agent 是基于基本的agent循环构建的——调用模型，让它选择执行的工具，然后在它不再调用任何工具时结束。

Middleware

中间件是create_agent的核心特性。它提供了一个高度可定制的入口点，提升了你能构建的应用的上限。
优秀的agent需要上下文工程：在正确的时间将正确的信息传递给模型。中间件通过可组合的抽象层，帮助您控制动态prompt、对话摘要、选择性工具访问、状态管理以及安全防护。

Prebuilt middleware

LangChain 提供了一些针对常见模式的预构建中间件，包括：
● PIIMiddleware：在发送给模型之前，对敏感信息进行脱敏处理
● SummarizationMiddleware：当对话历史过长时，对其进行压缩
● HumanInTheLoopMiddleware：要求对敏感工具调用进行人工审批

from langchain.agents import create_agent
from langchain.agents.middleware import (
    PIIMiddleware,
    SummarizationMiddleware,
    HumanInTheLoopMiddleware
)


agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=[read_email, send_email],
    middleware=[
        PIIMiddleware("email", strategy="redact", apply_to_input=True),
        PIIMiddleware(
            "phone_number",
            detector=(
                r"(?:\+?\d{1,3}[\s.-]?)?"
                r"(?:\(?\d{2,4}\)?[\s.-]?)?"
                r"\d{3,4}[\s.-]?\d{4}"
			),
			strategy="block"
        ),
        SummarizationMiddleware(
            model="claude-sonnet-4-5-20250929",
            trigger={"tokens": 500}
        ),
        HumanInTheLoopMiddleware(
            interrupt_on={
                "send_email": {
                    "allowed_decisions": ["approve", "edit", "reject"]
                }
            }
        ),
    ]
)

Custom middleware

你也可以根据需要构建自定义中间件。中间件在agent执行的每个步骤中都提供了钩子函数：

通过在AgentMiddleware类的子类上实现以下任一钩子函数来构建自定义中间件：

Hook	When it runs	Use cases
before_agent	执行agent前	加载内存，校验输入
before_model	每个LLM调用前	更新prompt，精简信息
wrap_model_call	包裹每次LLM调用	拦截并修改请求/响应
wrap_tool_call	包裹每次工具调用	拦截并修改工具执行
after_model	每次LLM响应后	验证输出，应用安全护栏
after_agent	agent执行完成后	保存结果，清理操作

自定义中间件示例：

from dataclasses import dataclass
from typing import Callable

from langchain_openai import ChatOpenAI

from langchain.agents.middleware import (
    AgentMiddleware,
    ModelRequest
)
from langchain.agents.middleware.types import ModelResponse

@dataclass
class Context:
    user_expertise: str = "beginner"

class ExpertiseBasedToolMiddleware(AgentMiddleware):
    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse]
    ) -> ModelResponse:
        user_level = request.runtime.context.user_expertise

        if user_level == "expert":
            # More powerful model
            model = ChatOpenAI(model="gpt-5")
            tools = [advanced_search, data_analysis]
        else:
            # Less powerful model
            model = ChatOpenAI(model="gpt-5-nano")
            tools = [simple_search, basic_calculator]

        return handler(request.override(model=model, tools=tools))

agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=[
        simple_search,
        advanced_search,
        basic_calculator,
        data_analysis
    ],
    middleware=[ExpertiseBasedToolMiddleware()],
    context_schema=Context
)

基于langgraph构建

由于create_agent是基于LangGraph构建的，因此通过以下特性你自动获得了对长时间运行和可靠agent的内置支持：
● Persistence（持久化）：通过内置检查点（checkpoint）功能，对话会自动跨会话持续进行。
● Streaming（流式）：实时流式处理token、工具调用和推理轨迹。
● Human-in-the-loop：在执行敏感操作之前暂停agent执行，等待人工批准。
● Time travel（时间旅行）：将对话回放到任意时间点，探索不同的路径和提示。
你不需要学习LangGraph就能使用这些功能——它们开箱即用。

结构化输出（Structured output）

create_agent 改进了结构化输出生成：
● 主循环集成：结构化输出现在在主循环中生成，而不再需要额外的LLM调用。
● 结构化输出策略：模型可以选择调用工具或使用提供商端的结构化输出生成方式。
● 成本降低：消除了额外调用LLM带来的额外开支。

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


class Weather(BaseModel):
    temperature: float
    condition: str

def weather_tool(city: str) -> str:
    """Get the weather for a city."""
    return f"it's sunny and 70 degrees in {city}"

agent = create_agent(
    "gpt-4o-mini",
    tools=[weather_tool],
    response_format=ToolStrategy(Weather)
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "What's the weather in SF?"}]
})

print(repr(result["structured_response"]))

# results in `Weather(temperature=70.0, condition='sunny')`

错误处理：通过ToolStrategy中的handle_errors参数来控制错误处理。
● 解析错误：模型生成的数据与期望的结构不匹配。
● 多工具调用：模型生成2个以上的工具调用以实现结构化输出模式。
（这里说的应该是错误处理的两种场景）

标准content blocks

目前，内容块支持功能仅适用于以下集成：
● langchain-anthropic
● langchain-aws
● langchain-openai
● langchain-google-genai
● langchain-ollama
我们将逐步扩展对更多提供商的内容块支持。

新的 content_blocks 属性引入了一种标准化的消息内容表示方式，适用于不同提供商：

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-5-20250929")
response = model.invoke("What's the capital of France?")

# Unified access to content blocks
for block in response.content_blocks:
    if block["type"] == "reasoning":
        print(f"Model reasoning: {block['reasoning']}")
    elif block["type"] == "text":
        print(f"Response: {block['text']}")
    elif block["type"] == "tool_call":
        print(f"Tool call: {block['name']}({block['args']})")

好处

● 提供商无关：无论使用哪个提供商，都可以通过相同的API访问推理轨迹、引用、内置工具（如网络搜索、代码解释器等）以及其他功能。
● 类型安全：所有内容块类型都提供完整的类型提示。
● 向后兼容：标准内容可以延迟加载，因此不会带来破坏性的更改。
（意思应该是content_blocks属性用某种方式将不同提供商的大模型响应解析为一种统一的格式，在代码中可以通过固定的字段去访问）

简化包

LangChain v1 简化了 langchain 包的命名空间，专注于为agent提供必要的构建模块。优化后的命名空间展示了最有用和最相关的功能：

命名空间

Module	What’s available	Notes
langchain.agents	create_agent, AgentState	核心agent创建功能
langchain.messages	Message types, content blocks, trim_messages	从 langchain-core 重新导出
langchain.tools	@tool, BaseTool, injection helpers	从 langchain-core 重新导出
langchain.chat_models	init_chat_model, BaseChatModel	统一模型初始化
langchain.embeddings	Embeddings, init_embeddings	嵌入模型相关

其中大部分是为了方便起见从 langchain-core 重新导出的，这为你提供了一个专注于构建agent的 API 接口。

# Agent building
from langchain.agents import create_agent

# Messages and content
from langchain.messages import AIMessage, HumanMessage

# Tools
from langchain.tools import tool

# Model initialization
from langchain.chat_models import init_chat_model
from langchain.embeddings import init_embeddings

langchain-classic

老的遗留功能已移至 langchain-classic，以保持核心包的精简和专注。
langchain-classic中的内容：
● 遗留链和链实现
● 检索器（例如 MultiQueryRetriever 或来自之前 langchain.retrievers 模块的任何内容）
● 索引 API
● Hub 模块（用于以编程方式管理提示）
● langchain-community 导出
● 其他已弃用的功能
使用这些功能需要安装langchain-classic：

pip install langchain-classic

然后更新导入：

from langchain import ...
from langchain_classic import ...

from langchain.chains import ...
from langchain_classic.chains import ...

from langchain.retrievers import ...
from langchain_classic.retrievers import ...

from langchain import hub  
from langchain_classic import hub

总结

以上内容主要机翻自langchain v1的发布说明，介绍了langchain v1的新变化，主要有以下几个方面：
● create_agent（创建agent的主要接口）
● 中间件Middleware（核心特性）
● 主循环response_format（减少LLM调用，降低消耗）
● 标准content blocks（目前仅支持部分提供商）
● 包改动（核心主要部件都从langchain导出，旧的移入langchain-classic）