OpenAI LLM models

Overview

OpenAI models are available in LiveKit Agents through LiveKit Inference and the OpenAI plugin. With LiveKit Inference, your agent runs on LiveKit's infrastructure to minimize latency. No separate provider API key is required, and usage and rate limits are managed through LiveKit Cloud. Use the plugin instead if you want to manage your own billing and rate limits. 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. You can use this LLM in the Voice AI quickstart:

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_handling, etc.
)

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

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

Parameters

The following are parameters for configuring OpenAI models with LiveKit Inference. For model behavior parameters like temperature and reasoning_effort, see model parameters.

Model parameters

Pass the following parameters inside extra_kwargs (Python) or modelOptions (Node.js). For more details about each parameter in the list, see Inference parameters.

String descriptors

As a shortcut, you can also pass a model ID 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_handling, etc.
)

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

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

Plugin

LiveKit's plugin support for OpenAI lets you connect directly to OpenAI's API with your own API key.

Installation

Install the plugin:

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_handling, etc.
)

import { voice } from '@livekit/agents';
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, turnHandling, 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_handling, etc.
)

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

// Use Responses API (recommended)
const session = new voice.AgentSession({
    llm: new 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_handling, etc.
)

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

// Chat Completions API (use openai.responses.LLM() for new projects)
const session = new voice.AgentSession({
    llm: new openai.LLM({ model: "gpt-4.1" }),
    // ... tts, stt, vad, turnHandling, 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.

Provider tools

OpenAI supports the following provider tools that enable the model to use built-in capabilities executed on the model server. These tools can be used alongside function tools defined in your agent's codebase. Provider tools require the Responses API.

from livekit.plugins import openai

agent = MyAgent(
    llm=openai.responses.LLM(model="gpt-4.1"),
    tools=[openai.tools.WebSearch()],  # replace with any supported provider tool
)

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.