用户
class Add(BaseModel): """ 将两个数字相加 """ a: int = Field(..., description="第一个数字") b: int = Field(..., description="第二个数字") def invoke(self, args): # 验证参数 tool_instance = self.__class__(**args) # 自动验证 a 和 b return tool_instance.a + tool_instance.b
DeepSeek AI

这段代码存在一个关键问题:`invoke` 方法中的参数验证方式会产生无限递归或逻辑混乱。

问题分析

python
复制
下载
def invoke(self, args):
    tool_instance = self.__class__(**args)  # 创建新实例
    return tool_instance.a + tool_instance.b

这里的问题:

  1. 实例重复创建:`invoke` 作为实例方法,但内部又用 `self.__class__(**args)` 创建了新实例,完全忽略了已有的 `self` 对象

  2. 参数验证时机:BaseModel 在 `__init__` 时已经验证过字段,再次实例化是多余的

  3. 无法访问实例属性:如果直接返回 `self.a + self.b`,会简单高效得多

正确的实现方式

方案一:直接使用实例属性(推荐)

python
复制
下载
class Add(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    def invoke(self):
        # 直接使用 self 的属性
        return self.a + self.b

# 使用示例
add = Add(a=3, b=5)
result = add.invoke()  # 返回 8

方案二:类方法模式(如果需要从字典创建)

python
复制
下载
class Add(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    @classmethod
    def invoke_from_dict(cls, args: dict):
        instance = cls(**args)  # 创建实例并验证
        return instance.a + instance.b

# 使用示例
result = Add.invoke_from_dict({"a": 3, "b": 5})  # 返回 8

方案三:静态方法模式(适合无状态工具)

python
复制
下载
class Add(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    @staticmethod
    def invoke(args: dict):
        # 手动验证
        validated = Add(**args)
        return validated.a + validated.b

改进建议

根据你的使用场景,建议采用方案一,因为:

如果必须接收字典参数,采用方案二会更合理。

用户
我记得有@validate装饰好像
DeepSeek AI

你说的应该是 Pydantic 的 `@validate_call` 装饰器-1-4-11。它确实很接近你想象中的“@validate装饰”,但名字稍有不同。

`@validate_call` 是什么?

它的核心作用是:在函数被调用前,根据函数的类型注解自动验证和转换参数,验证失败会抛出 `ValidationError`-1。它把 Pydantic 的验证能力从数据模型扩展到了普通函数上。

简单用一下你 `Add` 的例子,可以这么写:

python
复制
下载
from pydantic import validate_call

@validate_call
def add(a: int, b: int) -> int:
    """将两个数字相加"""
    return a + b

# 调用时会自动进行验证和类型转换
result = add(3, 5)      # 正常,返回 8
result2 = add("4", "6") # 也能工作,字符串 '4' 和 '6' 会被自动转为整数 4 和 6
# add("wrong", 5)       # 会抛出 ValidationError

这样写,你就不需要再定义一个继承自 `BaseModel` 的 `Add` 类,代码会更简洁。

对比你之前的 `BaseModel` 写法

方式适用场景特点
`@validate_call` 装饰器单个独立函数-1-4-11。轻量简洁,验证逻辑与函数绑定,调用即验证。
`BaseModel` 类LangChain 工具 (Tool) 等需要复杂输入模式的场景-6。结构清晰,可复用,便于生成 API 文档,能更好地与框架集成-6。

补充:其他的"验证装饰器"

你在搜索时还可能看到其他几个名字,它们用途不同:

总结建议

用户
1. field_validator和model_validator分别举例 2. langchain 使用 pydantic定义的类 可以直接作为tool吗, 和@tool装饰一样的吗
DeepSeek AI

好的,关于 `field_validator` 和 `model_validator` 的具体用法,以及 LangChain 中 Pydantic 类和 `@tool` 装饰器的关系,我找到了清晰的示例和说明。

1. field_validator 和 model_validator 示例

`field_validator` 和 `model_validator` 是 Pydantic 提供的两种内置校验机制,它们分工明确,构成了一个层层递进的校验体系-7。

代码示例

下面这个例子演示了注册时的用户名处理和密码确认校验-7:

python
复制
下载
from pydantic import BaseModel, Field, field_validator, model_validator

class RegisterVo(BaseModel):
    username: str = Field(..., min_length=2, max_length=20, description="用户名")
    password: str = Field(..., min_length=6, max_length=20, description="密码")
    confirm_password: str = Field(..., description="确认密码")

    # 1. @field_validator: 对 username 字段进行额外清洗和校验
    @field_validator("username")
    @classmethod
    def username_must_valid(cls, v: str) -> str:
        # 去掉前后空格
        cleaned = v.strip()
        # 自定义业务规则:英文名至少3字符,中文名至少2字符
        if cleaned.isascii():
            if len(cleaned) < 3:
                raise ValueError("英文用户名至少需要 3 个字符")
        else:
            if len(cleaned) < 2:
                raise ValueError("中文用户名至少需要 2 个字符")
        return cleaned

    # 2. @model_validator: 校验 password 和 confirm_password 是否一致
    @model_validator(mode="after")
    def check_passwords_match(self) -> 'RegisterVo':
        if self.password != self.confirm_password:
            raise ValueError("两次输入的密码不一致")
        return self

关键语法点:

2. LangChain 中 Pydantic 类与 `@tool` 装饰器的关系

在 LangChain 中,使用 Pydantic 定义的类可以作为工具,而 `@tool` 装饰器则是快速创建工具的便捷方式,两者并非完全相同,但可以结合使用。

python
复制
下载
from pydantic import BaseModel, Field
from langchain_core.tools import tool

# 1. 定义输入参数的 Schema
class WeatherInput(BaseModel):
    location: str = Field(description="城市和州,例如 San Francisco, CA")

# 2. 使用 @tool 并指定 args_schema
@tool(args_schema=WeatherInput)
def get_weather(location: str) -> str:
    """获取指定地点的当前天气"""
    # ... 实现获取天气的逻辑
    return f"The weather in {location} is sunny."
python
复制
下载
from langchain_anthropic import ChatAnthropic
from pydantic import BaseModel, Field

class GetWeather(BaseModel):
    """获取指定地点的当前天气"""
    location: str = Field(..., description="城市和州,例如 San Francisco, CA")

model = ChatAnthropic(model="...")
# 直接将 Pydantic 类传入 bind_tools
model_with_tools = model.bind_tools([GetWeather]) 

简单来说,定义工具时 `Pydantic 类 + @tool(args_schema=...)` 是最实用、标准的组合。而在像 `bind_tools` 这样的API中,Pydantic 类可以直接被使用,无需装饰器。

用户
@field_validator("username") @classmethod 这个顺序有关系吗 field_validator这个方法就是返回一个属性 model_validator(mode="after")这个方法before和after时机 他们都是自动校验的吗, 不需要手动调用装饰的方法是吧 bind_tools 这样的API中,Pydantic 类可以直接被使用, 那如果Pydantic 类 + @tool(args_schema=...)经过装饰呢, 不需要bind_tools 怎么用
DeepSeek AI

针对你的几个问题,我来逐一详细解答:

1. `@field_validator` 与 `@classmethod` 的顺序关系

顺序有关系,且必须是 `@field_validator` 在上,`@classmethod` 在下。

python
复制
下载
# ✅ 正确
@field_validator("username")
@classmethod
def username_must_valid(cls, v: str) -> str:
    return v.strip()

# ❌ 错误 - 会报错
@classmethod
@field_validator("username")
def username_must_valid(cls, v: str) -> str:
    return v.strip()

原因:装饰器是从下往上执行的。当 `@classmethod` 在下面时,它先被执行,将函数变成类方法。然后 `@field_validator` 收到的是一个类方法对象,而不是普通函数,导致 Pydantic 无法正确识别和注册这个校验器。

2. `model_validator(mode="after")` 的 before 和 after 时机

模式执行时机能访问的数据常见用途
`mode="before"`在字段校验之前执行只能访问原始输入数据(未验证的 dict)数据预处理、类型转换、字段重命名映射
`mode="after"`在所有字段校验之后执行能访问已校验的完整模型实例 (`self`)跨字段依赖校验(如密码确认)、计算派生字段
python
复制
下载
class User(BaseModel):
    name: str
    age: int
    
    @model_validator(mode="before")
    @classmethod
    def pre_process(cls, data: Any) -> Any:
        """在校验前:将 'full_name' 映射为 'name'"""
        if isinstance(data, dict) and "full_name" in data:
            data["name"] = data.pop("full_name")
        return data
    
    @model_validator(mode="after")
    def post_validate(self) -> 'User':
        """在校验后:检查年龄合理性"""
        if self.age < 0:
            raise ValueError("年龄不能为负数")
        return self

3. 校验器是自动执行的吗?

是的,完全自动执行,不需要手动调用。

python
复制
下载
# 你只需要创建实例
user = User(name="Alice", age=25)  # ✅ 自动触发所有校验器

# 或者使用 parse 方法
user = User.model_validate({"name": "Bob", "age": 30})  # ✅ 同样自动触发

# 校验失败会自动抛出 ValidationError
# user = User(name="A", age=-5)  # ❌ 自动抛出 ValidationError

Pydantic 在 `__init__` 和 `model_validate` 等入口处已经集成了校验流程,所有标记了 `@field_validator` 和 `@model_validator` 的方法都会在适当的时机被自动调用。

4. 不通过 `bind_tools` 如何使用 Pydantic 类作为工具?

如果不想用 `bind_tools`,你有以下几种方式:

方式一:`@tool` 装饰器 + `args_schema`(最常用)

python
复制
下载
from langchain_core.tools import tool

class GetWeatherInput(BaseModel):
    location: str = Field(description="城市名称")

@tool(args_schema=GetWeatherInput)
def get_weather(location: str) -> str:
    """获取天气信息"""
    return f"Weather in {location}: Sunny"

# 直接使用
result = get_weather.invoke({"location": "Beijing"})

方式二:直接实例化 `StructuredTool`

python
复制
下载
from langchain_core.tools import StructuredTool

class AddInput(BaseModel):
    a: int = Field(description="第一个数字")
    b: int = Field(description="第二个数字")

def add_func(a: int, b: int) -> int:
    return a + b

# 手动创建工具
tool = StructuredTool.from_function(
    func=add_func,
    name="add",
    description="将两个数字相加",
    args_schema=AddInput,  # 使用 Pydantic 类作为输入模式
)

# 使用
result = tool.invoke({"a": 3, "b": 5})  # 返回 8

方式三:继承 `BaseTool`(最灵活)

python
复制
下载
from langchain_core.tools import BaseTool
from typing import Type

class MultiplyTool(BaseTool):
    name: str = "multiply"
    description: str = "两个数字相乘"
    args_schema: Type[BaseModel] = MultiplyInput  # 定义输入模式
    
    def _run(self, a: int, b: int) -> int:
        """同步执行"""
        return a * b
    
    async def _arun(self, a: int, b: int) -> int:
        """异步执行"""
        return a * b

# 使用
tool = MultiplyTool()
result = tool.invoke({"a": 4, "b": 3})  # 返回 12

方式四:直接传递给 ChatModel(类似 bind_tools)

python
复制
下载
from langchain_openai import ChatOpenAI

class SearchInput(BaseModel):
    query: str = Field(description="搜索关键词")

model = ChatOpenAI()
# 直接将 Pydantic 类传入 tools 参数
model_with_tools = model.bind_tools([SearchInput])
# 或者使用更底层的 API
response = model.invoke("搜索 LangChain", tools=[SearchInput])

总结

使用场景推荐方式
简单工具,快速开发`@tool(args_schema=PydanticClass)`
需要自定义执行逻辑`StructuredTool.from_function()`
复杂工具,需要状态管理继承 `BaseTool`
与 ChatModel 集成`model.bind_tools([PydanticClass])`

Pydantic 类在这些场景中都是作为 `args_schema`(参数模式)存在的,作用是告诉 LangChain 和 LLM 这个工具需要什么参数、参数类型和描述。校验逻辑由 Pydantic 自动处理,你无需额外操心。

用户
@model_validator(mode="before") @classmethod def pre_process(cls, data: Any) -> Any: """在校验前:将 'full_name' 映射为 'name'""" if isinstance(data, dict) and "full_name" in data: data["name"] = data.pop("full_name") return data 感觉是不是 alias参数就是这么执行的
DeepSeek AI

你的直觉非常准确!`alias` 参数本质上就是在 `mode="before"` 阶段进行字段映射。它们实现的是同一件事,只是 `alias` 是 Pydantic 官方提供的声明式语法糖,而你手写的 `pre_process` 是显式的手动实现。

官方 `alias` 的实现原理

python
复制
下载
from pydantic import BaseModel, Field

class User(BaseModel):
    name: str = Field(..., alias="full_name")  # 声明别名
    age: int

# 使用时传入 full_name
user = User(full_name="Alice", age=25)
print(user.name)  # 输出: Alice
print(user.model_dump())  # 输出: {'name': 'Alice', 'age': 25}

Pydantic 在内部处理 `alias` 时,正是在 `mode="before"` 阶段做了类似你手写代码的事情:

python
复制
下载
# Pydantic 内部伪代码(简化版)
@model_validator(mode="before")
@classmethod
def _apply_aliases(cls, data: Any) -> Any:
    if isinstance(data, dict):
        for field_name, field_info in cls.model_fields.items():
            if field_info.alias and field_info.alias in data:
                data[field_name] = data.pop(field_info.alias)
    return data

对比:`alias` vs 手写 `pre_process`

对比项使用 `alias`手写 `pre_process`
代码量简洁,一行声明需要写完整的校验器逻辑
可读性高,语义清晰中等,需要阅读函数实现
维护性低维护,Pydantic 自动处理需要自己维护映射逻辑
IDE 支持好,类型提示和自动补全一般,data 是 Any 类型
灵活性仅支持字段映射可以做任意数据预处理(类型转换、默认值、条件处理等)

什么时候用 `alias`,什么时候手写?

使用 `alias` 的场景(推荐)

python
复制
下载
class User(BaseModel):
    user_id: int = Field(alias="id")  # 输入接受 id,输出为 user_id
    email: str
    
user = User(id=123, email="test@test.com")
print(user.model_dump(by_alias=True))  # 输出: {'id': 123, 'email': 'test@test.com'}

使用手写 `pre_process` 的场景

python
复制
下载
@model_validator(mode="before")
@classmethod
def complex_preprocess(cls, data: Any) -> Any:
    if not isinstance(data, dict):
        return data
    
    # 1. 兼容多种字段名
    if "full_name" in data:
        data["name"] = data.pop("full_name")
    elif "fullName" in data:
        data["name"] = data.pop("fullName")
    
    # 2. 复杂类型转换
    if "birth_date" in data and isinstance(data["birth_date"], str):
        data["birth_date"] = datetime.fromisoformat(data["birth_date"])
    
    # 3. 条件默认值
    if "role" not in data:
        data["role"] = "user" if data.get("age", 0) < 18 else "admin"
    
    return data

更优雅的替代方案:`field_validator` + `default_factory`

对于复杂预处理,有时可以使用组合方式:

python
复制
下载
from pydantic import BaseModel, Field, field_validator
from datetime import datetime

class User(BaseModel):
    name: str
    birth_date: str  # 先接收字符串
    age: int = Field(default_factory=lambda: 0)  # 默认值
    
    @field_validator("birth_date", mode="before")
    @classmethod
    def parse_date(cls, v: str) -> datetime:
        """将字符串转换为 datetime"""
        if isinstance(v, str):
            return datetime.fromisoformat(v)
        return v

总结

你的直觉实际情况
✅ `alias` 就是在 `before` 阶段做字段映射完全正确!`alias` 是 Pydantic 对最常见预处理场景(字段重命名)的声明式封装
区别`alias` 简洁但功能单一,手写 `pre_process` 灵活但代码多
最佳实践能用 `alias` 就用 `alias`,确实需要复杂预处理时才手写 `@model_validator(mode="before")`

所以,你理解得完全正确!`alias` 其实就是 Pydantic 把"字段名映射"这个常见的 `before` 阶段处理包装成了更易用的语法糖。

用户
class Add(BaseModel): """ 将两个数字相加 """ a: int = Field(..., description="第一个数字") b: int = Field(..., description="第二个数字") def invoke(self, args): # 验证参数 tool_instance = self.__class__(**args) # 自动验证 a 和 b return tool_instance.a + tool_instance.b 这里要想省去实例化类, 是不是可以@classmethed, 内部用cls(**args)
DeepSeek AI

你的想法完全正确!使用 `@classmethod` 可以省去外部实例化,直接通过类调用。下面是几种优化方案:

方案一:使用 `@classmethod`(你的想法)

python
复制
下载
from pydantic import BaseModel, Field
from typing import Any

class Add(BaseModel):
    """
    将两个数字相加
    """
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    @classmethod
    def invoke(cls, args: dict) -> int:
        """直接通过类调用,内部完成验证和计算"""
        instance = cls(**args)  # 自动验证 a 和 b
        return instance.a + instance.b

# 使用方式 - 无需实例化
result = Add.invoke({"a": 3, "b": 5})
print(result)  # 输出: 8

方案二:更简洁 - 使用 `@staticmethod`

如果不需要访问类属性,直接用静态方法更简洁:

python
复制
下载
class Add(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    @staticmethod
    def invoke(args: dict) -> int:
        """验证并执行加法"""
        validated = Add(**args)
        return validated.a + validated.b

# 使用
result = Add.invoke({"a": 3, "b": 5})

方案三:使用 Pydantic 的 `model_validate`

python
复制
下载
class Add(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    @classmethod
    def invoke(cls, args: dict) -> int:
        """使用 model_validate 进行验证"""
        instance = cls.model_validate(args)  # 更明确的验证方式
        return instance.a + instance.b

方案四:结合 `@tool` 装饰器(LangChain 场景)

如果是为 LangChain 定义工具,更推荐这样:

python
复制
下载
from langchain_core.tools import tool

class AddInput(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

@tool(args_schema=AddInput)
def add(a: int, b: int) -> int:
    """将两个数字相加"""
    return a + b

# 使用 - LangChain 自动处理验证
result = add.invoke({"a": 3, "b": 5})

对比分析

方案优点缺点适用场景
原始实例方法符合 OOP 设计需要先实例化,多一步需要维护状态的场景
`@classmethod`无需实例化,语义清晰仍需要在内部创建实例工具类,无状态的场景
`@staticmethod`最简洁硬编码类名,继承时可能有问题简单工具函数
`model_validate`明确表示验证意图同 `@classmethod`需要区分验证方式的场景
`@tool` 装饰器LangChain 原生支持,最简洁依赖 LangChainLangChain 项目

最佳实践建议

如果这是独立的工具类:

python
复制
下载
class Add(BaseModel):
    a: int = Field(..., description="第一个数字")
    b: int = Field(..., description="第二个数字")

    @classmethod
    def invoke(cls, args: dict) -> int:
        """类方法调用,无需实例化"""
        instance = cls(**args)
        return instance.a + instance.b

# 清晰的调用方式
result = Add.invoke({"a": 3, "b": 5})

如果这是 LangChain 工具:

python
复制
下载
@tool(args_schema=Add)
def add(a: int, b: int) -> int:
    """将两个数字相加"""
    return a + b

# 更符合 LangChain 生态

如果想完全避免实例化:

python
复制
下载
from pydantic import TypeAdapter

# 直接使用 TypeAdapter,不需要定义类
adapter = TypeAdapter(Dict[str, int])  # 但这样无法描述字段含义

# 更好的方式:还是保留 Pydantic 类用于验证

总结

你的想法 `@classmethod + cls(**args)` 完全可行,且比原始代码优雅很多。选择哪种方案取决于你的使用场景:

无论哪种方式,都比原始代码中的 `self.__class__(**args)` 更清晰合理!

用户
agent = initialize_agent(tools, llm, AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True) 使用langchain的agent相关的api直接调用工具, 讲解一下这个方法, 是否还有其他方式
DeepSeek AI

`initialize_agent` 是 LangChain 早期版本(0.x 系列)中用于创建 Agent 执行器的经典方法。它本身是一个便捷的工厂函数,作用是基于你提供的工具、LLM 和 Agent 类型,自动组装并返回一个`AgentExecutor`对象-1-4-6。

不过,随着 LangChain 的演进,尤其是进入 1.0 版本后,官方已经推荐使用更现代、更灵活的方式来构建 Agent-10。

🧠 `initialize_agent` 方法详解

这个方法简化了 Agent 的构建流程,其核心就是帮你把各种组件“粘合”起来。

Agent 类型核心特点与适用场景
`STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION`你正在用的类型。专为聊天模型优化,能够调用多输入参数的工具,很适合复杂的对话式任务-2-11。
`ZERO_SHOT_REACT_DESCRIPTION`“零样本”推理,通过“思考-行动”循环来完成任务。是默认的通用类型-2-4-6。
`OPENAI_FUNCTIONS`专门为支持OpenAI 函数调用功能的模型优化,工具调用更精准高效-2-7。
`CONVERSATIONAL_REACT_DESCRIPTION`专为多轮对话设计,能更好地保持对话上下文-2-7。

🆕 其他创建 Agent 的方式

随着 LangChain 的迭代,现在有更被推荐的方案:

  1. `create_agent` 函数 (LangChain 1.0+ 的推荐方式)
    这是 LangChain 1.0 中构建 Agent 的新标准-3-10。相比 `initialize_agent`,它的接口更简洁,并且引入了中间件 (Middleware) 的概念。中间件让你能以非常灵活的方式扩展 Agent 的功能,例如自动总结对话历史、拦截和处理工具调用、以及进行内容审核等-10。它旨在提供一个既容易上手又高度可定制的新入口。

    python
    复制
    下载
    from langchain.agents import create_agent
    
    agent = create_agent(
        model="claude-sonnet-4-6", # 指定模型,用法更简洁
        tools=[my_tool1, my_tool2],
        system_prompt="你是一个乐于助人的助手。"
    )
    # 使用方式和 AgentExecutor 类似
    result = agent.invoke({"messages": [...]})

    -3-10

  2. `LangGraph` (底层编排框架)
    如果说 `initialize_agent` 和 `create_agent` 是帮你组装好的“整车”,那 LangGraph 就是让你可以自己设计并制造“车”的工厂。它是一个底层的编排框架,`create_agent` 内部实际上就是基于它构建的-5-8。

    • 适用场景:当你需要非常精细地控制 Agent 的执行流程时,比如需要实现复杂的条件分支(IF/ELSE)、循环重试、并行执行多个任务,或者在工作流中加入人工审批环节(Human-in-the-Loop),LangGraph 是最合适的选择-5-8。

    • 核心概念:它的核心是“图”(Graph),由“节点”(Node,代表一个函数/步骤)和“边”(Edge,决定执行流向)构成,你需要自己定义整个工作流的逻辑-5。

🎯 如何选择?

简单来说,这是一个关于“控制层级”的选择:

方法抽象层级优点适用场景
`initialize_agent`高 (经典)快速上手,集成了多种预设的 Agent 策略。旧项目维护;使用早期 LangChain 版本的场景。
`create_agent`高 (现代)LangChain 1.0 官方推荐。接口简洁,通过中间件实现高度灵活的功能扩展。大部分新的 LangChain 项目,特别是需要对话摘要、内容审核等通用增强功能的场景-10。
`LangGraph`低 (底层)最大的控制权,可以实现任意复杂的定制化工作流。需要精细控制流程、长时运行、复杂多步骤逻辑或人机协同的复杂应用-5-8。
用户
实现防止死循环的早停策略 create_agent这个指定的模型直接写模型名称, 不用传递base_url和api_key吗
DeepSeek AI

这两个问题都很关键,我分别来回答。

⏹️ 实现防止死循环的早停策略

防止 Agent 陷入死循环,通常需要组合使用多层策略,从“硬限制”到“智能检测”逐层递进。

第一层:设置最大迭代次数 (`max_iterations`)

这是最基础也最直接的防护,为 Agent 的执行步数设定一个硬上限。当达到这个阈值时,Agent 会强制终止。

第二层:设置递归限制 (`recursion_limit`)

这是 LangGraph 底层引擎的安全限制,控制图中可以执行的步骤总数。`create_agent` 返回的 Agent 基于 LangGraph,因此受此限制。

第三层:使用中间件 (Middleware) 进行智能检测

这是 `create_agent` 提供的更高级、更智能的方式。中间件可以在 Agent 的每一步执行前后插入逻辑,用于检测重复模式并主动干预。

这三层策略通常结合使用:用 `max_iterations` 和 `recursion_limit` 兜底,用中间件进行更智能的检测和干预。

🔑 `create_agent` 的模型配置 (base_url & api_key)

关于你问的 `create_agent` 指定模型时是否需要传递 `base_url` 和 `api_key`,答案是:`create_agent` 本身不直接配置这些,而是通过它接收的 `model` 参数(即你创建的 LLM 实例)来配置的。

因此,你需要先构造一个已配置好 `base_url` 和 `api_key` 的模型实例,再传给 `create_agent`。这样做的好处是可以支持多种服务提供商-2-5-8。

配置方式详解

1. 使用 OpenAI
只需设置环境变量 `OPENAI_API_KEY`,或直接在初始化时传入。

python
复制
下载
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent

# 方式一:使用环境变量
model = ChatOpenAI(model="gpt-4o-mini")

# 方式二:显式传入 API Key
model = ChatOpenAI(model="gpt-4o-mini", api_key="your-api-key")

agent = create_agent(model=model, tools=[])

2. 使用其他兼容 OpenAI 接口的服务
很多服务(如 OpenRouter, Perplexity, Ollama, Azure)都兼容 OpenAI 的 API 格式,通过指定 `base_url` 和 `api_key` 即可接入-2-5-8。

python
复制
下载
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent

# 以 Perplexity 为例 [citation:8][citation:11]
model = ChatOpenAI(
    base_url="https://api.perplexity.ai/v1",  # 指定服务端点
    api_key=os.environ["PERPLEXITY_API_KEY"], # 使用对应服务的 API Key
    model="openai/gpt-5.6-sol",               # 指定具体模型名称
    use_responses_api=True,                   # 某些服务需要的特殊参数
)

# 以本地 Ollama 为例 [citation:5]
model = ChatOpenAI(
    base_url="http://localhost:11434/v1",
    api_key="none", # Ollama 通常不需要 key
    model="gemma4:e4b",
)

agent = create_agent(model=model, tools=[])

可以看到,`create_agent` 的灵活性在于它将连接配置(`base_url`, `api_key`)与模型选择(`model`)都封装在了 `ChatOpenAI` 这个模型实例里-2-5-8。