OpenAI LLM models

Overview

OpenAI models are available in LiveKit Agents through LiveKit Inference and the OpenAI plugin. Pricing for LiveKit Inference is available on the pricing page.

LiveKit Inference

Use LiveKit Inference to access OpenAI models without a separate OpenAI API key.

Usage

To use OpenAI, use the LLM class from the inference module:

from livekit.agents import AgentSession, inference

session = AgentSession(
    llm=inference.LLM(
        model="openai/gpt-5-mini", 
        provider="openai",
        extra_kwargs={
            "reasoning_effort": "low"
        }
    ),
    # ... tts, stt, vad, turn_detection, etc.
)

import { AgentSession, inference } from '@livekit/agents';

session = new AgentSession({
    llm: new inference.LLM({ 
        model: "openai/gpt-5-mini", 
        provider: "openai",
        modelOptions: { 
            reasoning_effort: "low" 
        }
    }),
    // ... tts, stt, vad, turn_detection, etc.
});

Parameters

String descriptors

As a shortcut, you can also pass a model descriptor string directly to the llm argument in your AgentSession:

from livekit.agents import AgentSession

session = AgentSession(
    llm="openai/gpt-4.1-mini",
    # ... tts, stt, vad, turn_detection, etc.
)

import { AgentSession } from '@livekit/agents';

session = new AgentSession({
    llm: "openai/gpt-4.1-mini",
    // ... tts, stt, vad, turn_detection, etc.
});

Plugin

Use the OpenAI plugin to connect directly to OpenAI's API with your own API key.

Installation

Install the plugin from PyPI:

uv add "livekit-agents[openai]~=1.4"

pnpm add @livekit/agents-plugin-openai@1.x

Authentication

The OpenAI plugin requires an OpenAI API key.

Set OPENAI_API_KEY in your .env file.

Usage

Use OpenAI within an AgentSession or as a standalone LLM service. For example, you can use this LLM in the Voice AI quickstart.

from livekit.plugins import openai

# Use Responses API (recommended)
session = AgentSession(
    llm=openai.responses.LLM(
        model="gpt-4.1"
    ),
    # ... tts, stt, vad, turn_detection, etc.
)

import * as openai from '@livekit/agents-plugin-openai';

const session = new voice.AgentSession({
    llm: new openai.responses.LLM({
        model: "gpt-4.1"
    }),
    // ... tts, stt, vad, turn_detection, etc.
});

API modes

The OpenAI plugin supports two API modes: Responses API and Chat Completions API.

Responses API (Recommended)

The Responses API is the recommended mode. It provides:

• Support for OpenAI's provider tools (WebSearch, FileSearch, CodeInterpreter)
• Better performance and features
• Access to the latest OpenAI capabilities
• Lower costs

Use openai.responses.LLM() to access the Responses API:

from livekit.plugins import openai

# Use Responses API (recommended)
session = AgentSession(
    llm=openai.responses.LLM(model="gpt-4.1"),
    # ... tts, stt, vad, turn_detection, etc.
)

Chat Completions API

The Chat Completions API is available via openai.LLM(). This API mode is used for:

• OpenAI-compatible endpoints: Providers like Cerebras, Fireworks, Groq, etc. use openai.LLM.with_*() methods which rely on the Chat Completions API format (see OpenAI-compatible endpoints)
• Legacy code compatibility: Existing code that uses openai.LLM() directly

To use Chat Completions mode directly with OpenAI (not recommended for new projects):

from livekit.plugins import openai

# Chat Completions API (use openai.responses.LLM() for new projects)
session = AgentSession(
    llm=openai.LLM(model="gpt-4.1"),
    # ... tts, stt, vad, turn_detection, etc.
)

import * as openai from '@livekit/agents-plugin-openai';

// Chat Completions API (use openai.responses.LLM() for new projects)
const session = new voice.AgentSession({
    llm: openai.LLM({ model: "gpt-4o-mini" }),
    // ... tts, stt, vad, turn_detection, etc.
});

OpenAI-compatible endpoints

When using OpenAI-compatible endpoints with providers using Chat Completions mode, you should use openai.LLM() with the provider's with_*() method. These providers include:

• Cerebras: openai.LLM.with_cerebras()
• Fireworks: openai.LLM.with_fireworks()
• Groq: openai.LLM.with_groq()
• Perplexity: openai.LLM.with_perplexity()
• Telnyx: openai.LLM.with_telnyx()
• Together AI: openai.LLM.with_together()
• xAI: openai.LLM.with_x_ai()
• DeepSeek: openai.LLM.with_deepseek()

These providers are built on the Chat Completions API format, so they use openai.LLM() (not openai.responses.LLM()). The with_*() methods automatically configure the correct API mode. See the individual provider documentation for specific usage examples.

Parameters

This section describes some of the available parameters. See the plugin reference links in the Additional resources section for a complete list of all available parameters.

Additional resources

The following resources provide more information about using OpenAI with LiveKit Agents.

Python plugin

ReferenceGitHubPyPI

Node.js plugin

ReferenceGitHubNPM

OpenAI docs

OpenAI platform documentation.

Voice AI quickstart

Get started with LiveKit Agents and OpenAI.

OpenAI ecosystem overview

Overview of the entire OpenAI and LiveKit Agents integration.