> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-zh.cn/llms.txt
> Use this file to discover all available pages before exploring further.
# 模型
[大型语言模型](https://en.wikipedia.org/wiki/Large_language_model) 是强大的 AI 工具，能够像人类一样理解和生成文本。它们足够灵活，可以撰写内容、翻译语言、总结摘要和回答问题，而无需针对每个任务进行专门的训练。
除了文本生成外，许多模型还支持：
* [工具调用](#tool-calling) - 调用外部工具（如数据库查询或 API 调用）并在响应中使用结果。
* [结构化输出](#structured-output) - 模型的响应被约束为遵循定义的格式。
* [多模态](#multimodal) - 处理和返回除文本以外的数据，例如图像、音频和视频。
* [推理](#reasoning) - 模型执行多步推理以得出结论。
模型是 [智能体](/oss/javascript/langchain/agents) 的推理引擎。它们驱动智能体的决策过程，确定调用哪些工具、如何解释结果以及何时提供最终答案。
您选择的模型的质量和能力直接影响智能体的基线可靠性和性能。不同的模型擅长不同的任务——有些更擅长遵循复杂指令，有些更擅长结构化推理，有些则支持更大的上下文窗口以处理更多信息。
LangChain 的标准模型接口让您能够访问许多不同的提供商集成，这使得实验和切换模型以找到最适合您用例的模型变得容易。
有关特定于提供程序的集成信息和功能，请参阅提供程序的 [聊天模型页面](/oss/javascript/integrations/chat)。
## 基本用法
模型可以通过两种方式利用：
1. **与智能体配合** - 在创建 [智能体](/oss/javascript/langchain/agents#model) 时可以动态指定模型。
2. **独立使用** - 可以直接调用模型（在智能体循环之外）用于文本生成、分类或提取等任务，而无需智能体框架。
相同的模型接口适用于这两种上下文，这为您提供了灵活性，可以从简单开始，并根据需要扩展到更复杂的基于智能体的工作流。
### 初始化模型
在 LangChain 中开始使用独立模型的最简单方法是使用 `initChatModel` 从您选择的 [聊天模型提供商](/oss/javascript/integrations/chat) 初始化一个（示例如下）：
👉 阅读 [OpenAI 聊天模型集成文档](/oss/javascript/integrations/chat/openai/)
```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/openai
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm install @langchain/openai
```
```bash yarn theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
yarn add @langchain/openai
```
```bash bun theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
bun add @langchain/openai
```
```typescript initChatModel theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { initChatModel } from "langchain";
process.env.OPENAI_API_KEY = "your-api-key";
const model = await initChatModel("gpt-5.2");
```
```typescript Model Class theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatOpenAI } from "@langchain/openai";
const model = new ChatOpenAI({
model: "gpt-5.2",
apiKey: "your-api-key"
});
```
👉 阅读 [Anthropic 聊天模型集成文档](/oss/javascript/integrations/chat/anthropic/)
```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/anthropic
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm install @langchain/anthropic
```
```bash yarn theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
yarn add @langchain/anthropic
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm add @langchain/anthropic
```
```typescript initChatModel theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { initChatModel } from "langchain";
process.env.ANTHROPIC_API_KEY = "your-api-key";
const model = await initChatModel("claude-sonnet-4-6");
```
```typescript Model Class theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatAnthropic } from "@langchain/anthropic";
const model = new ChatAnthropic({
model: "claude-sonnet-4-6",
apiKey: "your-api-key"
});
```
👉 阅读 [Azure 聊天模型集成文档](/oss/javascript/integrations/chat/azure/)
```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/azure
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm install @langchain/azure
```
```bash yarn theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
yarn add @langchain/azure
```
```bash bun theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
bun add @langchain/azure
```
```typescript initChatModel theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { initChatModel } from "langchain";
process.env.AZURE_OPENAI_API_KEY = "your-api-key";
process.env.AZURE_OPENAI_ENDPOINT = "your-endpoint";
process.env.OPENAI_API_VERSION = "your-api-version";
const model = await initChatModel("azure_openai:gpt-5.2");
```
```typescript Model Class theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { AzureChatOpenAI } from "@langchain/openai";
const model = new AzureChatOpenAI({
model: "gpt-5.2",
azureOpenAIApiKey: "your-api-key",
azureOpenAIApiEndpoint: "your-endpoint",
azureOpenAIApiVersion: "your-api-version"
});
```
👉 阅读 [Google GenAI 聊天模型集成文档](/oss/javascript/integrations/chat/google_generative_ai/)
```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/google-genai
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm install @langchain/google-genai
```
```bash yarn theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
yarn add @langchain/google-genai
```
```bash bun theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
bun add @langchain/google-genai
```
```typescript initChatModel theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { initChatModel } from "langchain";
process.env.GOOGLE_API_KEY = "your-api-key";
const model = await initChatModel("google-genai:gemini-2.5-flash-lite");
```
```typescript Model Class theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
const model = new ChatGoogleGenerativeAI({
model: "gemini-2.5-flash-lite",
apiKey: "your-api-key"
});
```
👉 阅读 [AWS Bedrock 聊天模型集成文档](/oss/javascript/integrations/chat/bedrock_converse/)
```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/aws
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm install @langchain/aws
```
```bash yarn theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
yarn add @langchain/aws
```
```bash bun theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
bun add @langchain/aws
```
```typescript initChatModel theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { initChatModel } from "langchain";
// 按照以下步骤配置您的凭据：
// https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
const model = await initChatModel("bedrock:gpt-5.2");
```
```typescript Model Class theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatBedrockConverse } from "@langchain/aws";
// 按照以下步骤配置您的凭据：
// https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
const model = new ChatBedrockConverse({
model: "gpt-5.2",
region: "us-east-2"
});
```
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const response = await model.invoke("Why do parrots talk?");
```
有关更多详细信息，包括如何传递模型 [参数](#parameters)，请参见 [`initChatModel`](https://reference.langchain.com/javascript/langchain/chat_models/universal/initChatModel)。
### 支持的模型
LangChain 支持所有主要模型提供商，包括 OpenAI、Anthropic、Google、Azure、AWS Bedrock 等。每个提供商都提供各种具有不同能力的模型。有关 LangChain 中支持的所有模型的完整列表，请参阅 [集成页面](/oss/javascript/integrations/providers/overview)。
### 关键方法
模型将消息作为输入，并在生成完整响应后输出消息。
调用模型，但在生成时实时流式传输输出。
批量向模型发送多个请求以实现更高效的处理。
除了聊天模型外，LangChain 还支持其他相关技术，例如嵌入模型和向量存储。有关详细信息，请参阅 [集成页面](/oss/javascript/integrations/providers/overview)。
## 参数
聊天模型接受可用于配置其行为的参数。支持参数的完整集因模型和提供商而异，但标准参数包括：
您希望使用的特定模型的名称或标识符。您还可以使用 '{model_provider}:{model}' 格式在单个参数中同时指定模型及其提供商，例如 'openai:o1'。
用于与模型提供商进行身份验证所需的密钥。这通常是在您注册访问模型时颁发的。通常通过设置 环境变量 来访问。
控制模型输出的随机性。较高的数字使响应更具创造性；较低的数字使响应更具确定性。
限制响应中的 令牌 总数，有效地控制输出可以有多长。
在取消请求之前等待模型响应的最长时间（以秒为单位）。
如果由于网络超时或速率限制等问题导致请求失败，系统将尝试重新发送请求的最大次数。重试使用带有抖动的指数退避。网络错误、速率限制 (429) 和服务器错误 (5xx) 会自动重试。客户端错误如 401（未授权）或 404 不会重试。对于不可靠网络上的长时间运行 [智能体](/oss/javascript/deepagents/overview) 任务，考虑将此增加到 10–15。
使用 `initChatModel`，将这些参数作为内联参数传递：
```typescript Initialize using model parameters theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const model = await initChatModel(
"claude-sonnet-4-6",
{ temperature: 0.7, timeout: 30, maxTokens: 1000, maxRetries: 6 }
)
```
每个聊天模型集成可能有额外的参数用于控制特定于提供商的功能。
例如，[`ChatOpenAI`](https://reference.langchain.com/javascript/langchain-openai/ChatOpenAI) 有 `use_responses_api` 来决定是使用 OpenAI Responses 还是 Completions API。
要查找给定聊天模型支持的所有参数，请访问 [聊天模型集成](/oss/javascript/integrations/chat) 页面。
***
## 调用
必须调用聊天模型才能生成输出。有三种主要的调用方法，每种方法都适用于不同的用例。
### 调用
调用模型最直接的方法是使用 [`invoke()`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#invoke) 并传入单条消息或消息列表。
```typescript Single message theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const response = await model.invoke("Why do parrots have colorful feathers?");
console.log(response);
```
可以向聊天模型提供消息列表以表示对话历史。每条消息都有一个角色，模型使用该角色指示对话中谁发送了消息。
有关角色、类型和内容的更多详细信息，请参阅 [消息](/oss/javascript/langchain/messages) 指南。
```typescript Object format theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const conversation = [
{ role: "system", content: "You are a helpful assistant that translates English to French." },
{ role: "user", content: "Translate: I love programming." },
{ role: "assistant", content: "J'adore la programmation." },
{ role: "user", content: "Translate: I love building applications." },
];
const response = await model.invoke(conversation);
console.log(response); // AIMessage("J'adore créer des applications.")
```
```typescript Message objects theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { HumanMessage, AIMessage, SystemMessage } from "langchain";
const conversation = [
new SystemMessage("You are a helpful assistant that translates English to French."),
new HumanMessage("Translate: I love programming."),
new AIMessage("J'adore la programmation."),
new HumanMessage("Translate: I love building applications."),
];
const response = await model.invoke(conversation);
console.log(response); // AIMessage("J'adore créer des applications.")
```
如果您的调用返回类型是字符串，请确保您使用的是聊天模型而不是 LLM。传统的文本补全 LLM 直接返回字符串。LangChain 聊天模型以前缀 "Chat" 开头，例如 [`ChatOpenAI`](https://reference.langchain.com/javascript/langchain-openai/ChatOpenAI)(/oss/integrations/chat/openai)。
### 流式传输
大多数模型可以在生成过程中流式传输其输出内容。通过渐进式显示输出，流式传输显著改善了用户体验，特别是对于较长的响应。
调用 [`stream()`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#stream) 返回一个 迭代器，该迭代器在产生时输出块。您可以使用循环实时处理每个块：
```typescript Basic text streaming theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const stream = await model.stream("Why do parrots have colorful feathers?");
for await (const chunk of stream) {
console.log(chunk.text)
}
```
```typescript Stream tool calls, reasoning, and other content theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const stream = await model.stream("What color is the sky?");
for await (const chunk of stream) {
for (const block of chunk.contentBlocks) {
if (block.type === "reasoning") {
console.log(`Reasoning: ${block.reasoning}`);
} else if (block.type === "tool_call_chunk") {
console.log(`Tool call chunk: ${block}`);
} else if (block.type === "text") {
console.log(block.text);
} else {
...
}
}
}
```
与 [`invoke()`](#invoke) 不同（它在模型完成生成完整响应后返回单个 [`AIMessage`](https://reference.langchain.com/javascript/langchain-core/messages/AIMessage)），`stream()` 返回多个 [`AIMessageChunk`](https://reference.langchain.com/javascript/langchain-core/messages/AIMessageChunk) 对象，每个对象包含一部分输出文本。重要的是，流中的每个块都设计为可以通过求和收集为完整消息：
```typescript Construct AIMessage theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
let full: AIMessageChunk | null = null;
for await (const chunk of stream) {
full = full ? full.concat(chunk) : chunk;
console.log(full.text);
}
// The
// The sky
// The sky is
// The sky is typically
// The sky is typically blue
// ...
console.log(full.contentBlocks);
// [{"type": "text", "text": "The sky is typically blue..."}]
```
生成的消息可以与使用 [`invoke()`](#invoke) 生成的消息一样处理——例如，它可以聚合到消息历史记录中，并作为对话上下文传递回模型。
仅当程序中的所有步骤都知道如何处理块流时，流式传输才有效。例如，无法流式传输的应用程序可能需要先在整个内存中存储输出才能进行处理。
LangChain 聊天模型也可以使用
\[`streamEvents()`]\[BaseChatModel.streamEvents] 流式传输语义事件。
这简化了基于事件类型和其他元数据的过滤，并将在后台聚合完整消息。下面是一个示例。
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const stream = await model.streamEvents("Hello");
for await (const event of stream) {
if (event.event === "on_chat_model_start") {
console.log(`Input: ${event.data.input}`);
}
if (event.event === "on_chat_model_stream") {
console.log(`Token: ${event.data.chunk.text}`);
}
if (event.event === "on_chat_model_end") {
console.log(`Full message: ${event.data.output.text}`);
}
}
```
```txt theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
Input: Hello
Token: Hi
Token: there
Token: !
Token: How
Token: can
Token: I
...
Full message: Hi there! How can I help today?
```
有关事件类型和其他详细信息，请参见 [`streamEvents()`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#streamEvents) 参考。
LangChain 通过在特定情况下自动启用流式传输模式来简化聊天模型的流式传输，即使您没有显式调用流式传输方法。当您使用非流式传输调用方法但仍希望流式传输整个应用程序（包括来自聊天模型的中间结果）时，这特别有用。
例如，在 [LangGraph 智能体](/oss/javascript/langchain/agents) 中，您可以在节点中调用 `model.invoke()`，但如果以流式传输模式运行，LangChain 将自动委托给流式传输。
#### 工作原理
当您 `invoke()` 聊天模型时，如果检测到您正在尝试流式传输整个应用程序，LangChain 将自动切换到内部流式传输模式。就使用 invoke 的代码而言，调用的结果将是相同的；然而，在聊天模型被流式传输时，LangChain 将负责在 LangChain 的回调系统中调用 [`on_llm_new_token`](https://reference.langchain.com/javascript/interfaces/_langchain_core.callbacks_base.BaseCallbackHandlerMethods.html#onLlmNewToken) 事件。
回调事件允许 LangGraph `stream()` 和 `streamEvents()` 实时显示聊天模型的输出。
### 批处理
将一组独立的请求批处理到模型中可以显著提高性能并降低成本，因为处理可以并行完成：
```typescript Batch theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const responses = await model.batch([
"Why do parrots have colorful feathers?",
"How do airplanes fly?",
"What is quantum computing?",
"Why do parrots have colorful feathers?",
"How do airplanes fly?",
"What is quantum computing?",
]);
for (const response of responses) {
console.log(response);
}
```
使用 `batch()` 处理大量输入时，您可能希望控制最大并行调用数。这可以通过在 [`RunnableConfig`](https://reference.langchain.com/javascript/langchain-core/runnables/RunnableConfig) 字典中设置 `maxConcurrency` 属性来完成。
```typescript Batch with max concurrency theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
model.batch(
listOfInputs,
{
maxConcurrency: 5, // Limit to 5 parallel calls
}
)
```
有关支持属性的完整列表，请参见 [`RunnableConfig`](https://reference.langchain.com/javascript/langchain-core/runnables/RunnableConfig) 参考。
有关批处理的更多详细信息，请参见 [reference](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#batch)。
***
## 工具调用
模型可以请求调用执行任务的工具，例如从数据库获取数据、搜索网络或运行代码。工具是以下两者的配对：
1. 一个模式，包括工具的名称、描述和/或参数定义（通常是 JSON 模式）
2. 一个函数或 协程 来执行。
您可能听说过“函数调用”一词。我们将其与“工具调用”互换使用。
以下是用户和模型之间的基本工具调用流程：
```mermaid theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
sequenceDiagram
participant U as User
participant M as Model
participant T as Tools
U->>M: "What's the weather in SF and NYC?"
M->>M: Analyze request & decide tools needed
par Parallel Tool Calls
M->>T: getWeather("San Francisco")
M->>T: getWeather("New York")
end
par Tool Execution
T-->>M: SF weather data
T-->>M: NYC weather data
end
M->>M: Process results & generate response
M->>U: "SF: 72°F sunny, NYC: 68°F cloudy"
```
要使您定义的工具可供模型使用，必须使用 [`bindTools`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#bindTools) 将它们绑定。在随后的调用中，模型可以选择按需调用任何绑定的工具。
某些模型提供商提供 内置工具，可以通过模型或调用参数启用（例如 [`ChatOpenAI`](/oss/javascript/integrations/chat/openai)、[`ChatAnthropic`](/oss/javascript/integrations/chat/anthropic)）。有关详细信息，请查看各自的 [提供商参考](/oss/javascript/integrations/providers/overview)。
有关创建工具的详细信息和其他选项，请参阅 [工具指南](/oss/javascript/langchain/tools)。
```typescript Binding user tools theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { tool } from "langchain";
import * as z from "zod";
import { ChatOpenAI } from "@langchain/openai";
const getWeather = tool(
(input) => `It's sunny in ${input.location}.`,
{
name: "get_weather",
description: "Get the weather at a location.",
schema: z.object({
location: z.string().describe("The location to get the weather for"),
}),
},
);
const model = new ChatOpenAI({ model: "gpt-4.1" });
const modelWithTools = model.bindTools([getWeather]); // [!code highlight]
const response = await modelWithTools.invoke("What's the weather like in Boston?");
const toolCalls = response.tool_calls || [];
for (const tool_call of toolCalls) {
// View tool calls made by the model
console.log(`Tool: ${tool_call.name}`);
console.log(`Args: ${tool_call.args}`);
}
```
绑定用户定义的工具时，模型的响应包括执行工具的**请求**。当单独使用模型而不使用 [智能体](/oss/javascript/langchain/agents) 时，您需要执行请求的工具并将结果返回给模型以供后续推理使用。当使用 [智能体](/oss/javascript/langchain/agents) 时，智能体循环将为您处理工具执行循环。
下面，我们展示了一些您可以使用工具调用的常见方式。
当模型返回工具调用时，您需要执行工具并将结果传递回模型。这会创建一个对话循环，模型可以使用工具结果生成最终响应。LangChain 包括 [智能体](/oss/javascript/langchain/agents) 抽象，为您处理此编排。
这是一个如何执行的简单示例：
```typescript Tool execution loop theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
// Bind (potentially multiple) tools to the model
const modelWithTools = model.bindTools([get_weather])
// Step 1: Model generates tool calls
const messages = [{"role": "user", "content": "What's the weather in Boston?"}]
const ai_msg = await modelWithTools.invoke(messages)
messages.push(ai_msg)
// Step 2: Execute tools and collect results
for (const tool_call of ai_msg.tool_calls) {
// Execute the tool with the generated arguments
const tool_result = await get_weather.invoke(tool_call)
messages.push(tool_result)
}
// Step 3: Pass results back to model for final response
const final_response = await modelWithTools.invoke(messages)
console.log(final_response.text)
// "The current weather in Boston is 72°F and sunny."
```
工具返回的每个 [`ToolMessage`](https://reference.langchain.com/javascript/langchain-core/messages/ToolMessage) 都包含一个 `tool_call_id`，它与原始工具调用匹配，帮助模型将结果与请求关联起来。
默认情况下，模型有权根据用户的输入选择使用哪个绑定的工具。但是，您可能希望强制选择工具，确保模型使用特定工具或给定列表中的**任何**工具：
```typescript Force use of any tool theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const modelWithTools = model.bindTools([tool_1], { toolChoice: "any" })
```
```typescript Force use of specific tools theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const modelWithTools = model.bindTools([tool_1], { toolChoice: "tool_1" })
```
许多模型支持在适当时并行调用多个工具。这允许模型同时从不同来源获取信息。
```typescript Parallel tool calls theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const modelWithTools = model.bind_tools([get_weather])
const response = await modelWithTools.invoke(
"What's the weather in Boston and Tokyo?"
)
// The model may generate multiple tool calls
console.log(response.tool_calls)
// [
// { name: 'get_weather', args: { location: 'Boston' }, id: 'call_1' },
// { name: 'get_time', args: { location: 'Tokyo' }, id: 'call_2' }
// ]
// Execute all tools (can be done in parallel with async)
const results = []
for (const tool_call of response.tool_calls || []) {
if (tool_call.name === 'get_weather') {
const result = await get_weather.invoke(tool_call)
results.push(result)
}
}
```
模型根据请求操作的独立性智能地确定何时并行执行是合适的。
大多数支持工具调用的模型默认启用并行工具调用。一些（包括 [OpenAI](/oss/javascript/integrations/chat/openai) 和 [Anthropic](/oss/javascript/integrations/chat/anthropic)）允许您禁用此功能。为此，请设置 `parallel_tool_calls=False`：
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
model.bind_tools([get_weather], parallel_tool_calls=False)
```
流式传输响应时，工具调用通过 [`ToolCallChunk`](https://reference.langchain.com/javascript/langchain-core/messages/ContentBlock/Tools/ToolCallChunk) 逐步构建。这允许您在生成时查看工具调用，而无需等待完整响应。
```typescript Streaming tool calls theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const stream = await modelWithTools.stream(
"What's the weather in Boston and Tokyo?"
)
for await (const chunk of stream) {
// Tool call chunks arrive progressively
if (chunk.tool_call_chunks) {
for (const tool_chunk of chunk.tool_call_chunks) {
console.log(`Tool: ${tool_chunk.get('name', '')}`)
console.log(`Args: ${tool_chunk.get('args', '')}`)
}
}
}
// Output:
// Tool: get_weather
// Args:
// Tool:
// Args: {"loc
// Tool:
// Args: ation": "BOS"}
// Tool: get_time
// Args:
// Tool:
// Args: {"timezone": "Tokyo"}
```
您可以累积块以构建完整的工具调用：
```typescript Accumulate tool calls theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
let full: AIMessageChunk | null = null
const stream = await modelWithTools.stream("What's the weather in Boston?")
for await (const chunk of stream) {
full = full ? full.concat(chunk) : chunk
console.log(full.contentBlocks)
}
```
***
## 结构化输出
可以要求模型以匹配给定模式的格式提供响应。这对于确保输出可以轻松解析并在后续处理中使用非常有用。LangChain 支持多种模式类型和强制执行结构化输出的方法。
要了解结构化输出，请参阅 [结构化输出](/oss/javascript/langchain/structured-output)。
[zod schema](https://zod.dev/) 是定义输出模式的首选方法。请注意，当提供 zod 模式时，模型输出也将使用 zod 的解析方法针对模式进行验证。
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import * as z from "zod";
const Movie = z.object({
title: z.string().describe("The title of the movie"),
year: z.number().describe("The year the movie was released"),
director: z.string().describe("The director of the movie"),
rating: z.number().describe("The movie's rating out of 10"),
});
const modelWithStructure = model.withStructuredOutput(Movie);
const response = await modelWithStructure.invoke("Provide details about the movie Inception");
console.log(response);
// {
// title: "Inception",
// year: 2010,
// director: "Christopher Nolan",
// rating: 8.8,
// }
```
为了获得最大的控制或互操作性，您可以提供原始 JSON Schema。
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const jsonSchema = {
"title": "Movie",
"description": "A movie with details",
"type": "object",
"properties": {
"title": {
"type": "string",
"description": "The title of the movie",
},
"year": {
"type": "integer",
"description": "The year the movie was released",
},
"director": {
"type": "string",
"description": "The director of the movie",
},
"rating": {
"type": "number",
"description": "The movie's rating out of 10",
},
},
"required": ["title", "year", "director", "rating"],
}
const modelWithStructure = model.withStructuredOutput(
jsonSchema,
{ method: "jsonSchema" },
)
const response = await modelWithStructure.invoke("Provide details about the movie Inception")
console.log(response) // {'title': 'Inception', 'year': 2010, ...}
```
任何实现 [Standard Schema](https://standardschema.dev/) 规范的库的模式也受支持。Standard Schema 对象通过模式的 `~standard.validate()` 方法在运行时进行验证。
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import * as v from "valibot";
import { toStandardJsonSchema } from "@valibot/to-json-schema";
const Movie = toStandardJsonSchema(
v.object({
title: v.pipe(v.string(), v.description("The title of the movie")),
year: v.pipe(v.number(), v.description("The year the movie was released")),
director: v.pipe(v.string(), v.description("The director of the movie")),
rating: v.pipe(v.number(), v.description("The movie's rating out of 10")),
})
);
const modelWithStructure = model.withStructuredOutput(Movie);
const response = await modelWithStructure.invoke("Provide details about the movie Inception");
console.log(response);
// {
// title: "Inception",
// year: 2010,
// director: "Christopher Nolan",
// rating: 8.8,
// }
```
**结构化输出的关键注意事项：**
* **Method 参数**：某些提供商支持不同的方法 (`'jsonSchema'`, `'functionCalling'`, `'jsonMode'`)
* **Include raw**：使用 [`includeRaw: true`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#withStructuredOutput) 以获取解析后的输出和原始 [`AIMessage`](https://reference.langchain.com/javascript/langchain-core/messages/AIMessage)
* **Validation**：Zod 和 Standard Schema 对象提供自动验证，而 JSON Schema 需要手动验证
* **Standard Schema**：任何实现 [Standard Schema](https://standardschema.dev/) 规范的库都受支持并在运行时进行验证
有关支持的方法和配置选项，请查看您的 [提供商集成页面](/oss/javascript/integrations/providers/overview)。
返回原始 [`AIMessage`](https://reference.langchain.com/javascript/langchain-core/messages/AIMessage) 对象 alongside 解析后的表示形式以访问响应元数据（如 [令牌用量](#token-usage)）可能很有用。为此，在调用 [`with_structured_output`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#withStructuredOutput) 时设置 [`include_raw=True`](https://reference.langchain.com/javascript/classes/_langchain_core.language_models_chat_models.BaseChatModel.html#withStructuredOutput)：
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import * as z from "zod";
const Movie = z.object({
title: z.string().describe("The title of the movie"),
year: z.number().describe("The year the movie was released"),
director: z.string().describe("The director of the movie"),
rating: z.number().describe("The movie's rating out of 10"),
title: z.string().describe("The title of the movie"),
year: z.number().describe("The year the movie was released"),
director: z.string().describe("The director of the movie"), // [!code highlight]
rating: z.number().describe("The movie's rating out of 10"),
});
const modelWithStructure = model.withStructuredOutput(Movie, { includeRaw: true });
const response = await modelWithStructure.invoke("Provide details about the movie Inception");
console.log(response);
// {
// raw: AIMessage { ... },
// parsed: { title: "Inception", ... }
// }
```
模式可以是嵌套的：
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import * as z from "zod";
const Actor = z.object({
name: str
role: z.string(),
});
const MovieDetails = z.object({
title: z.string(),
year: z.number(),
cast: z.array(Actor),
genres: z.array(z.string()),
budget: z.number().nullable().describe("Budget in millions USD"),
});
const modelWithStructure = model.withStructuredOutput(MovieDetails);
```
***
## 高级主题
### 模型档案
模型档案需要 `langchain>=1.1`。
LangChain 聊天模型可以通过 `profile` 属性暴露支持的功能和能力的字典：
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
model.profile;
// {
// maxInputTokens: 400000,
// imageInputs: true,
// reasoningOutput: true,
// toolCalling: true,
// ...
// }
```
有关字段的完整列表，请参见 [API 参考](https://reference.langchain.com/javascript/langchain-core/language_models/profile/ModelProfile)。
大部分模型档案数据由 [models.dev](https://github.com/sst/models.dev) 项目提供支持，这是一个提供模型能力数据的开源倡议。这些数据经过增强，添加了额外字段以用于与 LangChain 配合使用。这些增强内容与上游项目的演变保持一致。
模型档案数据允许应用程序动态绕过模型能力。例如：
1. [摘要中间件](/oss/javascript/langchain/middleware/built-in#summarization) 可以根据模型的上下文窗口大小触发摘要。
2. `createAgent` 中的 [结构化输出](/oss/javascript/langchain/structured-output) 策略可以自动推断（例如，通过检查对原生结构化输出功能的支持）。
3. 模型输入可以根据支持的 [模态](#multimodal) 和最大输入令牌进行限制。
4. [Deep Agents CLI](/oss/javascript/deepagents/cli) 将 [交互式模型切换器](/oss/javascript/deepagents/cli/providers#which-models-appear-in-the-switcher) 过滤为报告 `tool_calling` 支持和文本 I/O 的模型，并在选择器详细视图中显示上下文窗口大小和能力标志。
如果模型档案数据缺失、过时或不正确，可以更改它。
**选项 1（快速修复）**
您可以使用任何有效的档案实例化聊天模型：
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const customProfile = {
maxInputTokens: 100_000,
toolCalling: true,
structuredOutput: true,
// ...
};
const model = initChatModel("...", { profile: customProfile });
```
**选项 2（修复上游数据）**
数据的主要来源是 [models.dev](https://models.dev/) 项目。这些数据与 LangChain [集成包](/oss/javascript/integrations/providers/overview) 中的额外字段和覆盖合并，并随这些包一起分发。
模型档案数据可以通过以下过程更新：
1. （如果需要）通过向其 [GitHub 仓库](https://github.com/sst/models.dev) 提交拉取请求来更新 [models.dev](https://models.dev/) 处的源数据。
2. （如果需要）通过向 LangChain [集成包](/oss/javascript/integrations/providers/overview) 提交拉取请求来更新 `langchain-/profiles.toml` 中的额外字段和覆盖。
模型档案是一项 beta 功能。档案的格式可能会更改。
### 多模态
某些模型可以处理并返回非文本数据，如图像、音频和视频。您可以通过提供 [内容块](/oss/javascript/langchain/messages#message-content) 将非文本数据传递给模型。
所有具有底层多模态功能的 LangChain 聊天模型都支持：
1. 跨提供商标准格式的数据（见 [我们的消息指南](/oss/javascript/langchain/messages)）
2. OpenAI [聊天补全](https://platform.openai.com/docs/api-reference/chat) 格式
3. 特定于该提供商的任何格式（例如，Anthropic 模型接受 Anthropic 原生格式）
有关详细信息，请参阅消息指南的 [多模态部分](/oss/javascript/langchain/messages#multimodal)。
某些模型 可以在其响应中返回多模态数据。如果被调用这样做，生成的 [`AIMessage`](https://reference.langchain.com/javascript/langchain-core/messages/AIMessage) 将具有多模态类型的內容块。
```typescript Multimodal output theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const response = await model.invoke("Create a picture of a cat");
console.log(response.contentBlocks);
// [
// { type: "text", text: "Here's a picture of a cat" },
// { type: "image", data: "...", mimeType: "image/jpeg" },
// ]
```
有关特定提供商的详细信息，请参阅 [集成页面](/oss/javascript/integrations/providers/overview)。
### 推理
许多模型能够执行多步推理以得出结论。这涉及将复杂问题分解为更小、更易管理的步骤。
**如果底层模型支持**，您可以显示此推理过程以更好地了解模型如何得出最终答案。
```typescript Stream reasoning output theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const stream = model.stream("Why do parrots have colorful feathers?");
for await (const chunk of stream) {
const reasoningSteps = chunk.contentBlocks.filter(b => b.type === "reasoning");
console.log(reasoningSteps.length > 0 ? reasoningSteps : chunk.text);
}
```
```typescript Complete reasoning output theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const response = await model.invoke("Why do parrots have colorful feathers?");
const reasoningSteps = response.contentBlocks.filter(b => b.type === "reasoning");
console.log(reasoningSteps.map(step => step.reasoning).join(" "));
```
根据模型的不同，有时您可以指定它应该投入多少精力进行推理。同样，您可以要求模型完全关闭推理。这可能采取推理“层级”（例如，`'low'` 或 `'high'`）或整数令牌预算的形式。
有关详细信息，请查看您的相应聊天模型的 [集成页面](/oss/javascript/integrations/providers/overview) 或 [参考](https://reference.langchain.com/python/integrations/)。
### 本地模型
LangChain 支持在您自己的硬件上本地运行模型。这对于数据隐私至关重要的场景、您想调用自定义模型的场景，或者您想避免使用基于云的模型所产生的成本的场景非常有用。
[Ollama](/oss/javascript/integrations/chat/ollama) 是本地运行聊天和嵌入模型最简单的方法之一。
### 提示词缓存
许多提供商提供提示词缓存功能，以减少重复处理相同令牌的延迟和成本。这些功能可以是 **隐式** 或 **显式** 的：
* **隐式提示词缓存**：如果请求命中缓存，提供商将自动传递成本节省。示例：[OpenAI](/oss/javascript/integrations/chat/openai) 和 [Gemini](/oss/javascript/integrations/chat/google_generative_ai)。
* **显式缓存**：提供商允许您手动指示缓存点以获得更大的控制或保证成本节省。示例：
* [`ChatOpenAI`](https://reference.langchain.com/javascript/langchain-openai/ChatOpenAI)（通过 `prompt_cache_key`）
* Anthropic 的 [`AnthropicPromptCachingMiddleware`](/oss/javascript/integrations/chat/anthropic#prompt-caching)
* [Gemini](https://reference.langchain.com/python/integrations/langchain_google_genai/)。
* [AWS Bedrock](/oss/javascript/integrations/chat/bedrock#prompt-caching)
提示词缓存通常在最小输入令牌阈值以上才会启用。有关详细信息，请查看 [提供商页面](/oss/javascript/integrations/chat)。
缓存使用情况将反映在模型响应的 [用量元数据](/oss/javascript/langchain/messages#token-usage) 中。
### 服务端工具使用
某些提供商支持服务端 [工具调用](#tool-calling) 循环：模型可以与网络搜索、代码解释器和其他工具交互，并在单个对话回合中分析结果。
如果模型在服务端调用工具，响应消息的内容将包括代表工具调用和结果的內容。访问响应的 [内容块](/oss/javascript/langchain/messages#standard-content-blocks) 将以与提供商无关的格式返回服务端工具调用和结果：
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { initChatModel } from "langchain";
const model = await initChatModel("gpt-4.1-mini");
const modelWithTools = model.bindTools([{ type: "web_search" }])
const message = await modelWithTools.invoke("What was a positive news story from today?");
console.log(message.contentBlocks);
```
这代表单个对话回合；没有相关的 [ToolMessage](/oss/javascript/langchain/messages#tool-message) 对象需要在客户端 [工具调用](#tool-calling) 中传递。
有关可用工具和用法详细信息，请查看您的给定提供商的 [集成页面](/oss/javascript/integrations/chat)。
### 基础 URL 和代理设置
您可以为实施 OpenAI Chat Completions API 的提供商配置自定义基础 URL。
`model_provider="openai"`（或直接使用 `ChatOpenAI`）针对官方 OpenAI API 规范。路由器和代理的特定于提供商的字段可能不会被提取或保留。
对于 OpenRouter 和 LiteLLM，请使用专用集成：
* [OpenRouter via `ChatOpenRouter`](/oss/javascript/integrations/chat/openrouter) (`langchain-openrouter`)
* [LiteLLM via `ChatLiteLLM` / `ChatLiteLLMRouter`](/oss/javascript/integrations/chat) (`langchain-litellm`)
许多模型提供商提供 OpenAI 兼容 API（例如，[Together AI](https://www.together.ai/)、[vLLM](https://github.com/vllm-project/vllm)）。您可以通过指定适当的 `base_url` 参数使用 `initChatModel` 与这些提供商配合：
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
model = initChatModel(
"MODEL_NAME",
{
modelProvider: "openai",
baseUrl: "BASE_URL",
apiKey: "YOUR_API_KEY",
}
)
```
使用直接聊天模型类实例化时，参数名称可能因提供商而异。有关详细信息，请查看各自的 [参考](/oss/javascript/integrations/providers/overview)。
### 对数概率
某些模型可以配置为返回表示给定令牌可能性的令牌级对数概率，方法是在初始化模型时设置 `logprobs` 参数：
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const model = new ChatOpenAI({
model: "gpt-4.1",
logprobs: true,
});
const responseMessage = await model.invoke("Why do parrots talk?");
responseMessage.response_metadata.logprobs.content.slice(0, 5);
```
### Token 用量
许多模型提供商在调用响应中返回令牌用量信息。当可用时，此信息将包含在相应模型生成的 [`AIMessage`](https://reference.langchain.com/javascript/langchain-core/messages/AIMessage) 对象中。有关更多详细信息，请参阅 [消息](/oss/javascript/langchain/messages) 指南。
某些提供商 API，特别是 OpenAI 和 Azure OpenAI 聊天补全，要求用户在流式传输上下文中选择接收令牌用量数据。有关详细信息，请查看集成指南的 [流式传输用量元数据](/oss/javascript/integrations/chat/openai#streaming-usage-metadata) 部分。
### 调用配置
调用模型时，您可以使用 [`RunnableConfig`](https://reference.langchain.com/javascript/langchain-core/runnables/RunnableConfig) 对象通过 `config` 参数传递其他配置。这提供了对执行行为、回调和元数据跟踪的运行时控制。
常见的配置选项包括：
```typescript Invocation with config theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
const response = await model.invoke(
"Tell me a joke",
{
runName: "joke_generation", // Custom name for this run
tags: ["humor", "demo"], # Tags for categorization
metadata: {"user_id": "123"}, # Custom metadata
callbacks: [my_callback_handler], // Callback handlers
}
)
```
这些配置值特别有用，当：
* 使用 [LangSmith](/langsmith/home) 跟踪进行调试
* 实现自定义日志记录或监控
* 在生产中控制资源使用
* 跟踪复杂管道中的调用
在日志和跟踪中标识此特定调用。不继承自子调用。
继承自所有子调用的标签，用于在调试工具中进行过滤和组织。
用于跟踪附加上下文的自定义键值对，继承自所有子调用。
在使用 `batch()` 时控制最大并行调用数。
用于监控和响应执行期间事件的处理器。
防止复杂管道中无限循环的链的最大递归深度。
有关所有支持属性的完整列表，请参见 [`RunnableConfig`](https://reference.langchain.com/javascript/langchain-core/runnables/RunnableConfig) 参考。
***
[Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/i18n\zh-CN\oss\langchain\models.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).
[Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.