> ## Documentation Index
> Fetch the complete documentation index at: https://docs.langchain.com/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenAI integrations

> Integrate with OpenAI using LangChain JavaScript.

All functionality related to OpenAI

> [OpenAI](https://en.wikipedia.org/wiki/OpenAI) is American artificial intelligence (AI) research laboratory
> consisting of the non-profit `OpenAI Incorporated`
> and its for-profit subsidiary corporation `OpenAI Limited Partnership`.
> OpenAI conducts AI research with the declared intention of promoting and developing a friendly AI.
> OpenAI systems run on an `Azure`-based supercomputing platform from `Microsoft`.

> The [OpenAI API](https://platform.openai.com/docs/models) is powered by a diverse set of models with different capabilities and price points.
>
> [ChatGPT](https://chat.openai.com) is the Artificial Intelligence (AI) chatbot developed by `OpenAI`.

## Installation and setup

* Get an OpenAI api key and set it as an environment variable (`OPENAI_API_KEY`)

## Chat model

See a [usage example](/oss/javascript/integrations/chat/openai).

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatOpenAI } from "@langchain/openai";
```

## LLM

See a [usage example](/oss/javascript/integrations/llms/openai).

<Tip>
  See [this section for general instructions on installing LangChain packages](/oss/javascript/langchain/install).
</Tip>

```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/openai @langchain/core
```

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { OpenAI } from "@langchain/openai";
```

## Text embedding model

See a [usage example](/oss/javascript/integrations/embeddings/openai)

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { OpenAIEmbeddings } from "@langchain/openai";
```

## Chain

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { OpenAIModerationChain } from "@langchain/classic/chains";
```

## Middleware

Middleware specifically designed for OpenAI models. Learn more about [middleware](/oss/javascript/langchain/middleware/overview).

| Middleware                                | Description                                               |
| ----------------------------------------- | --------------------------------------------------------- |
| [Content moderation](#content-moderation) | Moderate agent traffic using OpenAI's moderation endpoint |

### Content moderation

Moderate agent traffic (user input, model output, and tool results) using OpenAI's moderation endpoint to detect and handle unsafe content. Content moderation is useful for the following:

* Applications requiring content safety and compliance
* Filtering harmful, hateful, or inappropriate content
* Customer-facing agents that need safety guardrails
* Meeting platform moderation requirements

<Info>
  Learn more about [OpenAI's moderation models](https://platform.openai.com/docs/guides/moderation) and categories.
</Info>

**API reference:** [`openAIModerationMiddleware`](https://reference.langchain.com/javascript/langchain/index/openAIModerationMiddleware)

```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { createAgent, openAIModerationMiddleware } from "langchain";

const agent = createAgent({
  model: "openai:gpt-5.4",
  tools: [searchTool, databaseTool],
  middleware: [
    openAIModerationMiddleware({
      model: "openai:gpt-5.4",
      moderationModel: "omni-moderation-latest",
      checkInput: true,
      checkOutput: true,
      exitBehavior: "end",
    }),
  ],
});
```

<Accordion title="Configuration options">
  <ParamField body="model" type="string | BaseChatModel" required>
    OpenAI model to use for moderation. Can be either a model name string (e.g., `"openai:gpt-5.4"`) or a `BaseChatModel` instance. The middleware will use this model's client to access the moderation endpoint.
  </ParamField>

  <ParamField body="moderationModel" type="ModerationModel" default="omni-moderation-latest">
    OpenAI moderation model to use. Options: `'omni-moderation-latest'`, `'omni-moderation-2024-09-26'`, `'text-moderation-latest'`, `'text-moderation-stable'`
  </ParamField>

  <ParamField body="checkInput" type="boolean" default="true">
    Whether to check user input messages before the model is called
  </ParamField>

  <ParamField body="checkOutput" type="boolean" default="true">
    Whether to check model output messages after the model is called
  </ParamField>

  <ParamField body="checkToolResults" type="boolean" default="false">
    Whether to check tool result messages before the model is called
  </ParamField>

  <ParamField body="exitBehavior" type="'error' | 'end' | 'replace'" default="'end'">
    How to handle violations when content is flagged. Options:

    * `'end'` - End agent execution immediately with a violation message
    * `'error'` - Throw `OpenAIModerationError` exception
    * `'replace'` - Replace the flagged content with the violation message and continue
  </ParamField>

  <ParamField body="violationMessage" type="string | undefined">
    Custom template for violation messages. Supports template variables:

    * `{categories}` - Comma-separated list of flagged categories
    * `{category_scores}` - JSON string of category scores
    * `{original_content}` - The original flagged content

    Default: `"I'm sorry, but I can't comply with that request. It was flagged for {categories}."`
  </ParamField>
</Accordion>

<Accordion title="Full example">
  The middleware integrates OpenAI's moderation endpoint to check content at different stages:

  **Moderation stages:**

  * `checkInput` - User messages before model call
  * `checkOutput` - AI messages after model call
  * `checkToolResults` - Tool outputs before model call

  **Exit behaviors:**

  * `'end'` (default) - Stop execution with violation message
  * `'error'` - Throw exception for application handling
  * `'replace'` - Replace flagged content and continue

  ```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
  import { createAgent, openAIModerationMiddleware } from "langchain";

  // Basic moderation
  const agent = createAgent({
    model: "openai:gpt-5.4",
    tools: [searchTool, customerDataTool],
    middleware: [
      openAIModerationMiddleware({
        model: "openai:gpt-5.4",
        moderationModel: "omni-moderation-latest",
        checkInput: true,
        checkOutput: true,
      }),
    ],
  });

  // Strict moderation with custom message
  const agentStrict = createAgent({
    model: "openai:gpt-5.4",
    tools: [searchTool, customerDataTool],
    middleware: [
      openAIModerationMiddleware({
        model: "openai:gpt-5.4",
        moderationModel: "omni-moderation-latest",
        checkInput: true,
        checkOutput: true,
        checkToolResults: true,
        exitBehavior: "error",
        violationMessage:
          "Content policy violation detected: {categories}. " +
          "Please rephrase your request.",
      }),
    ],
  });

  // Moderation with replacement behavior
  const agentReplace = createAgent({
    model: "openai:gpt-5.4",
    tools: [searchTool],
    middleware: [
      openAIModerationMiddleware({
        model: "openai:gpt-5.4",
        checkInput: true,
        exitBehavior: "replace",
        violationMessage: "[Content removed due to safety policies]",
      }),
    ],
  });
  ```
</Accordion>

***

<div className="source-links">
  <Callout icon="terminal-2">
    [Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
  </Callout>

  <Callout icon="edit">
    [Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/oss/javascript/integrations/providers/openai.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).
  </Callout>
</div>