Class ChatOpenAI<CallOptions>

OpenAI chat model integration.

Setup: Install @langchain/openai and set environment variable OPENAI_API_KEY.

npm install @langchain/openai
export OPENAI_API_KEY="your-api-key"
Copy

Key args

Key init args — completion params:

Param: model

Name of OpenAI model to use.

Param: temperature

Sampling temperature.

Param: maxTokens

Max number of tokens to generate.

Param: logprobs

Whether to return logprobs.

Param: stream_options

Configure streaming outputs, like whether to return token usage when streaming ({ include_usage: true }).

Key init args — client params:

Param: timeout

Timeout for requests.

Param: maxRetries

Max number of retries.

Param: apiKey

OpenAI API key. If not passed in will be read from env var OPENAI_API_KEY.

Param: baseUrl

Base URL for API requests. Only specify if using a proxy or service emulator.

Param: organization

OpenAI organization ID. If not passed in will be read from env var OPENAI_ORG_ID.

Key bind args:

Param: tools

Tools to bind to the model.

Param: tool_choice

Specify how and/or which tool the model should invoke.

Param: promptIndex

Param: response_format

The format the model should respond in.

Param: seed

Seed for reproducibility.

Param: stream_options

Additional options to pass to streamed completions. If provided takes precedence over "streamUsage" set at initialization time.

Param: stream_options.include_usage

Whether or not to include token usage in the stream. If set to true, this will include an additional chunk at the end of the stream with the token usage.

Param: parallel_tool_calls

Whether or not to restrict the ability to call multiple tools in one response.

Param: strict

Whether or not to force the model to return structured output which exactly matches the schema.

See full list of supported init args and their descriptions in the params section.

Example

import { ChatOpenAI } from '@langchain/openai';

const llm = new ChatOpenAI({
  model: "gpt-4o",
  temperature: 0,
  maxTokens: undefined,
  timeout: undefined,
  maxRetries: 2,
  // apiKey: "...",
  // baseUrl: "...",
  // organization: "...",
  // other params...
});
Copy

Example

const messages = [
  {
    type: "system" as const,
    content: "You are a helpful translator. Translate the user sentence to French.",
  },
  {
    type: "human" as const,
    content: "I love programming.",
  },
];
const result = await llm.invoke(messages);
console.log(result);
Copy

Example

for await (const chunk of await llm.stream(messages)) {
  console.log(chunk);
}
Copy

Example

import { AIMessageChunk } from '@langchain/core/messages';
import { concat } from '@langchain/core/utils/stream';

const stream = await llm.stream(messages);
let full: AIMessageChunk | undefined;
for await (const chunk of stream) {
  full = !full ? chunk : concat(full, chunk);
}
console.log(full);
Copy

Example

import { z } from 'zod';

const GetWeather = {
  name: "GetWeather",
  description: "Get the current weather in a given location",
  schema: z.object({
    location: z.string().describe("The city and state, e.g. San Francisco, CA")
  }),
}

const GetPopulation = {
  name: "GetPopulation",
  description: "Get the current population in a given location",
  schema: z.object({
    location: z.string().describe("The city and state, e.g. San Francisco, CA")
  }),
}

const llmWithTools = llm.bindTools(
  [GetWeather, GetPopulation],
  {
    // strict: true  // enforce tool args schema is respected
  }
);
const aiMsg = await llmWithTools.invoke(
  "Which city is hotter today and which is bigger: LA or NY?"
);
console.log(aiMsg.tool_calls);
Copy

Example

import { z } from 'zod';

const Joke = z.object({
  setup: z.string().describe("The setup of the joke"),
  punchline: z.string().describe("The punchline to the joke"),
  rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
}).describe('Joke to tell user.');

const structuredLlm = llm.withStructuredOutput(Joke);
const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
console.log(jokeResult);
Copy

Example

const jsonLlm = llm.bind({ response_format: { type: "json_object" } });
const jsonLlmAiMsg = await jsonLlm.invoke(
  "Return a JSON object with key 'randomInts' and a value of 10 random ints in [0-99]"
);
console.log(jsonLlmAiMsg.content);
Copy

Example

import { HumanMessage } from '@langchain/core/messages';

const imageUrl = "https://example.com/image.jpg";
const imageData = await fetch(imageUrl).then(res => res.arrayBuffer());
const base64Image = Buffer.from(imageData).toString('base64');

const message = new HumanMessage({
  content: [
    { type: "text", text: "describe the weather in this image" },
    {
      type: "image_url",
      image_url: { url: `data:image/jpeg;base64,${base64Image}` },
    },
  ]
});

const imageDescriptionAiMsg = await llm.invoke([message]);
console.log(imageDescriptionAiMsg.content);
Copy

Example

const aiMsgForMetadata = await llm.invoke(messages);
console.log(aiMsgForMetadata.usage_metadata);
Copy

Example

const streamForMetadata = await llm.stream(
  messages,
  {
    stream_options: {
      include_usage: true
    }
  }
);
let fullForMetadata: AIMessageChunk | undefined;
for await (const chunk of streamForMetadata) {
  fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
}
console.log(fullForMetadata?.usage_metadata);
Copy

Example

const logprobsLlm = new ChatOpenAI({ logprobs: true });
const aiMsgForLogprobs = await logprobsLlm.invoke(messages);
console.log(aiMsgForLogprobs.response_metadata.logprobs);
Copy

Example

const aiMsgForResponseMetadata = await llm.invoke(messages);
console.log(aiMsgForResponseMetadata.response_metadata);
Copy