> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-5e9cc07a-preview-opensw-1783454697-4d4e2b4.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenAI integrations

> Integrate with OpenAI using LangChain JavaScript.

LangChain integrates with OpenAI and Azure OpenAI through the `@langchain/openai` package.

> [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={null}
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={null}
npm install @langchain/openai @langchain/core
```

```typescript theme={null}
import { OpenAI } from "@langchain/openai";
```

## Text embedding model

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

```typescript theme={null}
import { OpenAIEmbeddings } from "@langchain/openai";
```

## Chain

```typescript theme={null}
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={null}
import { createAgent, openAIModerationMiddleware } from "langchain";

const agent = createAgent({
  model: "openai:gpt-5.5",
  tools: [searchTool, databaseTool],
  middleware: [
    openAIModerationMiddleware({
      model: "openai:gpt-5.5",
      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.5"`) 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={null}
  import { createAgent, openAIModerationMiddleware } from "langchain";

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

  // Strict moderation with custom message
  const agentStrict = createAgent({
    model: "openai:gpt-5.5",
    tools: [searchTool, customerDataTool],
    middleware: [
      openAIModerationMiddleware({
        model: "openai:gpt-5.5",
        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.5",
    tools: [searchTool],
    middleware: [
      openAIModerationMiddleware({
        model: "openai:gpt-5.5",
        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>