这段代码存在一个关键问题:`invoke` 方法中的参数验证方式会产生无限递归或逻辑混乱。
def invoke(self, args): tool_instance = self.__class__(**args) # 创建新实例 return tool_instance.a + tool_instance.b
这里的问题:
实例重复创建:`invoke` 作为实例方法,但内部又用 `self.__class__(**args)` 创建了新实例,完全忽略了已有的 `self` 对象
参数验证时机:BaseModel 在 `__init__` 时已经验证过字段,再次实例化是多余的
无法访问实例属性:如果直接返回 `self.a + self.b`,会简单高效得多
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
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
class Add(BaseModel): a: int = Field(..., description="第一个数字") b: int = Field(..., description="第二个数字") @staticmethod def invoke(args: dict): # 手动验证 validated = Add(**args) return validated.a + validated.b
根据你的使用场景,建议采用方案一,因为:
更符合面向对象设计
避免不必要的实例化开销
代码更简洁清晰
Pydantic 的验证在对象创建时已完成
如果必须接收字典参数,采用方案二会更合理。
你说的应该是 Pydantic 的 `@validate_call` 装饰器-1-4-11。它确实很接近你想象中的“@validate装饰”,但名字稍有不同。
它的核心作用是:在函数被调用前,根据函数的类型注解自动验证和转换参数,验证失败会抛出 `ValidationError`-1。它把 Pydantic 的验证能力从数据模型扩展到了普通函数上。
简单用一下你 `Add` 的例子,可以这么写:
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` 类,代码会更简洁。
| 方式 | 适用场景 | 特点 |
|---|---|---|
| `@validate_call` 装饰器 | 单个独立函数-1-4-11。 | 轻量简洁,验证逻辑与函数绑定,调用即验证。 |
| `BaseModel` 类 | LangChain 工具 (Tool) 等需要复杂输入模式的场景-6。 | 结构清晰,可复用,便于生成 API 文档,能更好地与框架集成-6。 |
你在搜索时还可能看到其他几个名字,它们用途不同:
`@field_validator` 和 `@model_validator`:这两个是专门用于 `BaseModel` 内部的,用来为某个字段或整个模型添加自定义校验逻辑,而不是直接装饰一个独立函数-2-3-9。
`@validate`:这是一个非常特定的第三方库(pico-pydantic)里的装饰器,并非 Pydantic 官方的通用功能-7。
好的,关于 `field_validator` 和 `model_validator` 的具体用法,以及 LangChain 中 Pydantic 类和 `@tool` 装饰器的关系,我找到了清晰的示例和说明。
`field_validator` 和 `model_validator` 是 Pydantic 提供的两种内置校验机制,它们分工明确,构成了一个层层递进的校验体系-7。
`Field` 是最基础的约束:它通过参数如 `min_length`、`ge`(大于等于)、`pattern`(正则匹配)等,直接对字段进行声明式校验-7-4。
`@field_validator` 处理单字段复杂逻辑:当 `Field` 的约束不够用时,用它来为一个或多个特定字段添加自定义校验逻辑。校验失败则抛出 `ValueError`-7-4。
`@model_validator` 处理跨字段联合校验:当校验需要比较多个字段的值(例如密码确认、日期范围)时,使用它。它能访问到整个模型的实例,进行字段间的联动检查-7-10。
下面这个例子演示了注册时的用户名处理和密码确认校验-7:
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
关键语法点:
`@field_validator("username")` 指定了它校验的字段名-7。
修饰器函数必须声明为 `@classmethod`,其第二个参数 `v` 是待校验的字段值-7。
`@model_validator(mode="after")` 表示在模型实例创建之后执行,此时可以安全地通过 `self` 访问所有字段的值-10-7。
在 LangChain 中,使用 Pydantic 定义的类可以作为工具,而 `@tool` 装饰器则是快速创建工具的便捷方式,两者并非完全相同,但可以结合使用。
Pydantic 类作为 `args_schema`:这是最常见和推荐的方式。你可以通过一个继承自 `BaseModel` 的类来精确定义工具的输入参数结构和描述。然后将这个类作为 `args_schema` 参数传给工具[cite:citation 8, citation:9]。这样能让大模型更准确地理解如何调用你的工具。
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."
直接使用 Pydantic 类:在更高级的用法中,例如使用 `bind_tools()` 时,可以直接传入 Pydantic 模型类。LangChain 会自动将模型转换为工具所需的格式,非常简洁-2。
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])
与 `@tool` 装饰器的区别:
简单来说,定义工具时 `Pydantic 类 + @tool(args_schema=...)` 是最实用、标准的组合。而在像 `bind_tools` 这样的API中,Pydantic 类可以直接被使用,无需装饰器。
针对你的几个问题,我来逐一详细解答:
顺序有关系,且必须是 `@field_validator` 在上,`@classmethod` 在下。
# ✅ 正确 @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 无法正确识别和注册这个校验器。
| 模式 | 执行时机 | 能访问的数据 | 常见用途 |
|---|---|---|---|
| `mode="before"` | 在字段校验之前执行 | 只能访问原始输入数据(未验证的 dict) | 数据预处理、类型转换、字段重命名映射 |
| `mode="after"` | 在所有字段校验之后执行 | 能访问已校验的完整模型实例 (`self`) | 跨字段依赖校验(如密码确认)、计算派生字段 |
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
是的,完全自动执行,不需要手动调用。
# 你只需要创建实例 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` 的方法都会在适当的时机被自动调用。
如果不想用 `bind_tools`,你有以下几种方式:
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"})
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
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
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 自动处理,你无需额外操心。
你的直觉非常准确!`alias` 参数本质上就是在 `mode="before"` 阶段进行字段映射。它们实现的是同一件事,只是 `alias` 是 Pydantic 官方提供的声明式语法糖,而你手写的 `pre_process` 是显式的手动实现。
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"` 阶段做了类似你手写代码的事情:
# 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` | 手写 `pre_process` |
|---|---|---|
| 代码量 | 简洁,一行声明 | 需要写完整的校验器逻辑 |
| 可读性 | 高,语义清晰 | 中等,需要阅读函数实现 |
| 维护性 | 低维护,Pydantic 自动处理 | 需要自己维护映射逻辑 |
| IDE 支持 | 好,类型提示和自动补全 | 一般,data 是 Any 类型 |
| 灵活性 | 仅支持字段映射 | 可以做任意数据预处理(类型转换、默认值、条件处理等) |
简单的字段名称映射(如 `full_name` -> `name`)
处理 API 响应字段命名不一致(如 JSON 返回 `user_id`,模型用 `userId`)
需要序列化控制(`serialization_alias` 控制输出名称)
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'}
复杂的数据转换(如时间字符串转 datetime 对象)
条件性字段映射(根据某个字段的值决定映射逻辑)
数据清洗和标准化(如统一大小写、去除空格)
兼容多个版本的 API 字段(如同时支持 `full_name` 和 `fullName`)
@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
对于复杂预处理,有时可以使用组合方式:
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` 阶段处理包装成了更易用的语法糖。
你的想法完全正确!使用 `@classmethod` 可以省去外部实例化,直接通过类调用。下面是几种优化方案:
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
如果不需要访问类属性,直接用静态方法更简洁:
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})
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
如果是为 LangChain 定义工具,更推荐这样:
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 原生支持,最简洁 | 依赖 LangChain | LangChain 项目 |
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})
@tool(args_schema=Add) def add(a: int, b: int) -> int: """将两个数字相加""" return a + b # 更符合 LangChain 生态
from pydantic import TypeAdapter # 直接使用 TypeAdapter,不需要定义类 adapter = TypeAdapter(Dict[str, int]) # 但这样无法描述字段含义 # 更好的方式:还是保留 Pydantic 类用于验证
你的想法 `@classmethod + cls(**args)` 完全可行,且比原始代码优雅很多。选择哪种方案取决于你的使用场景:
独立工具:`@classmethod` 方案最合适
LangChain 集成:`@tool` 装饰器方案更标准
追求极致简洁:`@staticmethod` 也可以
无论哪种方式,都比原始代码中的 `self.__class__(**args)` 更清晰合理!
`initialize_agent` 是 LangChain 早期版本(0.x 系列)中用于创建 Agent 执行器的经典方法。它本身是一个便捷的工厂函数,作用是基于你提供的工具、LLM 和 Agent 类型,自动组装并返回一个`AgentExecutor`对象-1-4-6。
不过,随着 LangChain 的演进,尤其是进入 1.0 版本后,官方已经推荐使用更现代、更灵活的方式来构建 Agent-10。
这个方法简化了 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。 |
返回值:它返回一个 `AgentExecutor` 对象-1-4-6。你可以把这个对象当作一个“AI 助手”来用,通过它的 `invoke` 方法传入用户问题,它会自动调用 LLM 和工具来完成任务。
随着 LangChain 的迭代,现在有更被推荐的方案:
`create_agent` 函数 (LangChain 1.0+ 的推荐方式)
这是 LangChain 1.0 中构建 Agent 的新标准-3-10。相比 `initialize_agent`,它的接口更简洁,并且引入了中间件 (Middleware) 的概念。中间件让你能以非常灵活的方式扩展 Agent 的功能,例如自动总结对话历史、拦截和处理工具调用、以及进行内容审核等-10。它旨在提供一个既容易上手又高度可定制的新入口。
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": [...]})
`LangGraph` (底层编排框架)
如果说 `initialize_agent` 和 `create_agent` 是帮你组装好的“整车”,那 LangGraph 就是让你可以自己设计并制造“车”的工厂。它是一个底层的编排框架,`create_agent` 内部实际上就是基于它构建的-5-8。
简单来说,这是一个关于“控制层级”的选择:
这两个问题都很关键,我分别来回答。
防止 Agent 陷入死循环,通常需要组合使用多层策略,从“硬限制”到“智能检测”逐层递进。
这是最基础也最直接的防护,为 Agent 的执行步数设定一个硬上限。当达到这个阈值时,Agent 会强制终止。
实现方式:在使用 `AgentExecutor` 时,直接设置 `max_iterations` 参数。不同 Agent 类型的默认值有所不同(如 `ReActAgent` 默认为 6,`StructuredChatAgent` 默认为 12),建议根据任务复杂度显式设置,简单任务 5-8 步,复杂任务 10-15 步,然后根据日志调优-4。
示例代码:
from langchain.agents import AgentExecutor agent_executor = AgentExecutor( agent=agent, tools=tools, max_iterations=10, # 设置最大循环次数 handle_parsing_errors=True, )
这是 LangGraph 底层引擎的安全限制,控制图中可以执行的步骤总数。`create_agent` 返回的 Agent 基于 LangGraph,因此受此限制。
实现方式:在调用 `agent.invoke()` 时,通过 `config` 参数传入`[citation:3][citation:6]`。
示例代码:
agent = create_agent(model, tools) # 在调用时设置递归限制 result = agent.invoke( {"messages": [{"role": "user", "content": "..."}]}, config={"recursion_limit": 100} # 默认是 25 )
这是 `create_agent` 提供的更高级、更智能的方式。中间件可以在 Agent 的每一步执行前后插入逻辑,用于检测重复模式并主动干预。
`ModelCallLimitMiddleware` (调用次数限制):可以直接限制模型被调用的次数,达到阈值后抛出错误终止流程-7。
`LoopDetectionMiddleware` (循环检测):可以跟踪 Agent 的行为,例如检测同一文件是否被反复编辑且毫无进展,一旦发现这种“微循环”,就向 Agent 注入提示词(nudge),引导它改变策略-1。
实现方式:将中间件实例传给 `create_agent` 的 `middleware` 参数。
示例代码:
from langchain.agents import create_agent from langchain.agents.middleware import ModelCallLimitMiddleware limit_middleware = ModelCallLimitMiddleware( run_limit=3, # 最多调用模型 3 次 exit_behavior="error", ) agent = create_agent( model=llm, tools=[...], middleware=[limit_middleware], # 应用中间件 )
这三层策略通常结合使用:用 `max_iterations` 和 `recursion_limit` 兜底,用中间件进行更智能的检测和干预。
关于你问的 `create_agent` 指定模型时是否需要传递 `base_url` 和 `api_key`,答案是:`create_agent` 本身不直接配置这些,而是通过它接收的 `model` 参数(即你创建的 LLM 实例)来配置的。
因此,你需要先构造一个已配置好 `base_url` 和 `api_key` 的模型实例,再传给 `create_agent`。这样做的好处是可以支持多种服务提供商-2-5-8。
1. 使用 OpenAI
只需设置环境变量 `OPENAI_API_KEY`,或直接在初始化时传入。
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。
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。