langchain 模型 - 聊天模型 (js版）_langchainjs

模型

模型是LangChain的核心组件。LangChain不是模型的提供者，而是提供了一个标准接口，通过该接口您可以与各种语言模型进行交互。
LangChain支持基于文本的大型语言模型（LLM）、聊天模型和文本嵌入模型。

LLM使用基于文本的输入和输出，而聊天模型使用基于消息的输入和输出。

注意: 聊天模型API还比较新，因此我们仍在探索正确的抽象。如果您有任何反馈，请告诉我们！

高级

此部分适用于希望深入了解LangChain工作原理的用户。如果您刚开始使用，可以跳过此部分。

LLM和聊天模型都是基于BaseLanguageModel类构建的。该类为所有模型提供了一个公共接口，并允许我们在不更改其余代码的情况下轻松更换模型。

BaseLanguageModel 类有两个抽象方法：generatePrompt 和 getNumTokens，分别由 BaseChatModel 和 BaseLLM 实现。

BaseLLM 是 BaseLanguageModel 的子类，为 LLMs 提供了一个公共接口，而 BaseChatModel 是 BaseLanguageModel 的子类，为聊天模型提供了一个公共接口。

入门：聊天模型

LangChain 提供了一个标准接口来使用聊天模型。聊天模型是语言模型的一种变体。
虽然聊天模型在内部使用语言模型，但它们公开的接口略有不同。
它们公开的接口不是“输入文本，输出文本”，而是将“聊天消息”作为输入和输出。

聊天消息

ChatMessage 是我们称之为聊天模型的信息模块单元。
目前，它由一个 "text" 字段组成，该字段指的是聊天消息的内容。

LangChain 目前支持四种不同类型的 ChatMessage：

• HumanChatMessage：以人类视角发送的聊天消息。
• AIChatMessage：从 AI 系统的视角发送的聊天消息，该系统与人类进行通信。
• SystemChatMessage：提供有关对话的一些信息的聊天消息。通常在对话开始时发送。
• ChatMessage：通用聊天消息，不仅具有 "text" 字段，还具有任意的 "role" 字段。

注意: 目前，我们仅支持 ChatOpenAI（使用 gpt-4 和 gpt-3.5-turbo）这一基于聊天的模型，但预计将来会添加更多模型。

要开始使用，只需使用 LLM 实现的 call 方法，传入一个 string 输入即可。在这个例子中，我们使用了 ChatOpenAI 实现：

import { ChatOpenAI } from "langchain/chat_models/openai";
import { HumanChatMessage } from "langchain/schema";

export const run = async () => {
  const chat = new ChatOpenAI();
  // Pass in a list of messages to `call` to start a conversation. In this simple example, we only pass in one message.
  const response = await chat.call([
    new HumanChatMessage(
      "What is a good name for a company that makes colorful socks?"
    ),
  ]);
  console.log(response);
  // AIChatMessage { text: '\n\nRainbow Sox Co.' }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

集成：聊天模型

LangChain提供了许多与各种模型提供商集成的聊天模型实现。这些包括：

ChatOpenAI

import { ChatOpenAI } from "langchain/chat_models/openai";

const model = new ChatOpenAI({
  temperature: 0.9,
  openAIApiKey: "YOUR-API-KEY", // In Node.js defaults to process.env.OPENAI_API_KEY
});
1
2
3
4
5
6

Azure ChatOpenAI

import { ChatOpenAI } from "langchain/chat_models/openai";

const model = new ChatOpenAI({
  temperature: 0.9,
  azureOpenAIApiKey: "YOUR-API-KEY", // In Node.js defaults to process.env.AZURE_OPENAI_API_KEY
  azureOpenAIApiInstanceName: "YOUR-INSTANCE-NAME", // In Node.js defaults to process.env.AZURE_OPENAI_API_INSTANCE_NAME
  azureOpenAIApiDeploymentName: "YOUR-DEPLOYMENT-NAME", // In Node.js defaults to process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME
  azureOpenAIApiVersion: "YOUR-API-VERSION", // In Node.js defaults to process.env.AZURE_OPENAI_API_VERSION
});
1
2
3
4
5
6
7
8
9

ChatAnthropic

import { ChatAnthropic } from "langchain/chat_models/anthropic";

const model = new ChatAnthropic({
  temperature: 0.9,
  apiKey: "YOUR-API-KEY", // In Node.js defaults to process.env.ANTHROPIC_API_KEY
});
1
2
3
4
5
6

Google Vertex AI

Vertex AI实现是用于Node.js而不是直接从浏览器中使用，因为它需要一个服务帐户来使用。

在运行此代码之前，您应确保Vertex AI API已启用相关项目，并且您已使用以下方法之一对Google Cloud进行了身份验证：

• 您已登录到一个帐户（使用 gcloud auth application-default login）允许访问该项目。
• 您正在运行在使用被允许访问该项目的服务帐户的机器上。
• 您已下载了一个被允许访问该项目的服务帐户的凭据，并将 GOOGLE_APPLICATION_CREDENTIALS 环境变量设置为此文件的路径。

npm install google-auth-library
1

ChatGoogleVertexAI 类的工作方式与其他基于聊天的 LLMs 相同，但有几个例外：

1. 传递的第一个 SystemChatMessage 映射到 PaLM 模型期望的 “context” 参数。不允许其他 SystemChatMessages。
2. 在第一个 SystemChatMessage 之后，必须有奇数条消息，表示人类和模型之间的对话。
3. 人类消息必须与 AI 消息交替。

import { ChatGoogleVertexAI } from "langchain/chat_models/googlevertexai";

const model = new ChatGoogleVertexAI({
  temperature: 0.7,
});
1
2
3
4
5

还有一个可选的 examples 构造函数参数，可以帮助模型了解适当的响应是什么样子的。

import { ChatGoogleVertexAI } from "langchain/chat_models/googlevertexai";
import {
  AIChatMessage,
  HumanChatMessage,
  SystemChatMessage,
} from "langchain/schema";

export const run = async () => {
  const examples = [
    {
      input: new HumanChatMessage("What is your favorite sock color?"),
      output: new AIChatMessage("My favorite sock color be arrrr-ange!"),
    },
  ];
  const model = new ChatGoogleVertexAI({
    temperature: 0.7,
    examples,
  });
  const questions = [
    new SystemChatMessage(
      "You are a funny assistant that answers in pirate language."
    ),
    new HumanChatMessage("What is your favorite food?"),
  ];
  // You can also use the model as part of a chain
  const res = await model.call(questions);
  console.log({ res });
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

---

附加功能：聊天模型

我们为聊天模型提供了许多附加功能。在下面的示例中，我们将使用 ChatOpenAI 模型。

附加方法

LangChain 提供了许多与聊天模型交互的附加方法：

import { ChatOpenAI } from "langchain/chat_models/openai";
import { HumanChatMessage, SystemChatMessage } from "langchain/schema";

export const run = async () => {
  const chat = new ChatOpenAI({ modelName: "gpt-3.5-turbo" });
  // Pass in a list of messages to `call` to start a conversation. In this simple example, we only pass in one message.
  const responseA = await chat.call([
    new HumanChatMessage(
      "What is a good name for a company that makes colorful socks?"
    ),
  ]);
  console.log(responseA);
  // AIChatMessage { text: '\n\nRainbow Sox Co.' }

  // You can also pass in multiple messages to start a conversation.
  // The first message is a system message that describes the context of the conversation.
  // The second message is a human message that starts the conversation.
  const responseB = await chat.call([
    new SystemChatMessage(
      "You are a helpful assistant that translates English to French."
    ),
    new HumanChatMessage("Translate: I love programming."),
  ]);
  console.log(responseB);
  // AIChatMessage { text: "J'aime programmer." }

  // Similar to LLMs, you can also use `generate` to generate chat completions for multiple sets of messages.
  const responseC = await chat.generate([
    [
      new SystemChatMessage(
        "You are a helpful assistant that translates English to French."
      ),
      new HumanChatMessage(
        "Translate this sentence from English to French. I love programming."
      ),
    ],
    [
      new SystemChatMessage(
        "You are a helpful assistant that translates English to French."
      ),
      new HumanChatMessage(
        "Translate this sentence from English to French. I love artificial intelligence."
      ),
    ],
  ]);
  console.log(responseC);
  /*
  {
    generations: [
      [
        {
          text: "J'aime programmer.",
          message: AIChatMessage { text: "J'aime programmer." },
        }
      ],
      [
        {
          text: "J'aime l'intelligence artificielle.",
          message: AIChatMessage { text: "J'aime l'intelligence artificielle." }
        }
      ]
    ]
  }
  */
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

流式传输

与 LLM 类似，您可以从聊天模型中流式传输响应。这对于需要实时响应用户输入的聊天机器人非常有用。

import { ChatOpenAI } from "langchain/chat_models/openai";
import { HumanChatMessage } from "langchain/schema";

const chat = new ChatOpenAI({
  maxTokens: 25,
  streaming: true,
});

const response = await chat.call(
  [new HumanChatMessage("Tell me a joke.")],
  undefined,
  [
    {
      handleLLMNewToken(token: string) {
        console.log({ token });
      },
    },
  ]
);

console.log(response);
// { token: '' }
// { token: '\n\n' }
// { token: 'Why' }
// { token: ' don' }
// { token: "'t" }
// { token: ' scientists' }
// { token: ' trust' }
// { token: ' atoms' }
// { token: '?\n\n' }
// { token: 'Because' }
// { token: ' they' }
// { token: ' make' }
// { token: ' up' }
// { token: ' everything' }
// { token: '.' }
// { token: '' }
// AIChatMessage {
//   text: "\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything."
// }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

添加超时

默认情况下，LangChain 将无限期地等待模型提供程序的响应。如果您想添加超时，可以在调用模型时传递一个以毫秒为单位的 timeout 选项。例如，对于 OpenAI：

import { ChatOpenAI } from "langchain/chat_models/openai";
import { HumanChatMessage } from "langchain/schema";

const chat = new ChatOpenAI({ temperature: 1 });

const response = await chat.call(
  [
    new HumanChatMessage(
      "What is a good name for a company that makes colorful socks?"
    ),
  ],
  { timeout: 1000 } // 1s timeout
);
console.log(response);
// AIChatMessage { text: '\n\nRainbow Sox Co.' }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

取消请求

当调用模型时，您可以通过传递 signal 选项来取消请求。例如，对于 OpenAI：

import { ChatOpenAI } from "langchain/chat_models/openai";
import { HumanChatMessage } from "langchain/schema";

const model = new ChatOpenAI({ temperature: 1 });
const controller = new AbortController();

// Call `controller.abort()` somewhere to cancel the request.

const res = await model.call(
  [
    new HumanChatMessage(
      "What is a good name for a company that makes colorful socks?"
    ),
  ],
  { signal: controller.signal }
);

console.log(res);
/*
'\n\nSocktastic Colors'
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

请注意，如果底层提供程序公开了该选项，则此操作仅会取消正在进行的请求。如果可能，LangChain 将取消底层请求，否则它将取消响应的处理。

处理速率限制

一些提供程序具有速率限制。如果您超过速率限制，您将收到一个错误。为了帮助您处理这个问题，LangChain 在实例化聊天模型时提供了一个 maxConcurrency 选项。此选项允许您指定要向提供程序发出的最大并发请求数。如果您超过此数字，LangChain 将自动将您的请求排队，以便在前面的请求完成后发送。

例如，如果您设置 maxConcurrency: 5，那么 LangChain 一次只会向提供程序发送 5 个请求。如果您发送了 10 个请求，则前 5 个请求将立即发送，而后面的 5 个请求将排队等待。一旦前 5 个请求中的一个完成，队列中的下一个请求将被发送。

使用此功能，只需在实例化LLM时传递maxConcurrency: <number>即可。例如：

import { ChatOpenAI } from "langchain/chat_models/openai";

const model = new ChatOpenAI({ maxConcurrency: 5 });
1
2
3

处理API错误

如果模型提供程序从其API返回错误，默认情况下，LangChain将在指数退避上重试最多6次。这使得错误恢复变得轻松无额外的努力。如果您想更改此行为，可以在实例化模型时传递maxRetries选项。例如：

import { ChatOpenAI } from "langchain/chat_models/openai";

const model = new ChatOpenAI({ maxRetries: 10 });
1
2
3

订阅事件

特别是在使用代理时，当聊天模型处理提示时，可能会有很多来回交流。对于代理，响应对象包含一个intermediateSteps对象，您可以打印它以查看它所采取的步骤的概述。如果这还不够，并且您想查看与聊天模型的每个交换，您可以将回调传递给聊天模型以进行自定义日志记录（或任何其他您想要执行的操作），因为模型通过步骤：

有关可用事件的更多信息，请参见文档中的回调部分。

import { HumanChatMessage, LLMResult } from "langchain/schema";
import { ChatOpenAI } from "langchain/chat_models/openai";

// We can pass in a list of CallbackHandlers to the LLM constructor to get callbacks for various events.
const model = new ChatOpenAI({
  callbacks: [
    {
      handleLLMStart: async (llm: { name: string }, prompts: string[]) => {
        console.log(JSON.stringify(llm, null, 2));
        console.log(JSON.stringify(prompts, null, 2));
      },
      handleLLMEnd: async (output: LLMResult) => {
        console.log(JSON.stringify(output, null, 2));
      },
      handleLLMError: async (err: Error) => {
        console.error(err);
      },
    },
  ],
});

await model.call([
  new HumanChatMessage(
    "What is a good name for a company that makes colorful socks?"
  ),
]);
/*
{
  "name": "openai"
}
[
  "Human: What is a good name for a company that makes colorful socks?"
]
{
  "generations": [
    [
      {
        "text": "Rainbow Soles",
        "message": {
          "text": "Rainbow Soles"
        }
      }
    ]
  ],
  "llmOutput": {
    "tokenUsage": {
      "completionTokens": 4,
      "promptTokens": 21,
      "totalTokens": 25
    }
  }
}
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53