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

# Get Started with LiveKit

> Learn how to build real-time voice AI agents using LiveKit with Cerebras Inference models for ultra-fast speech-to-text and language processing.

## What is LiveKit?

LiveKit is an open-source platform that enables scalable, multi-user conferencing with WebRTC. It provides the tools you need to add real-time video, audio, and data capabilities to your applications. By combining LiveKit with Cerebras's ultra-fast inference, you can build responsive voice AI agents that handle conversations with minimal latency.

Learn more at [LiveKit.io](https://livekit.io/?utm_source=3pi_livekit\&utm_campaign=partner_doc).

## Prerequisites

Before you begin, ensure you have:

* **Cerebras API Key** - Get a free API key [here](https://cloud.cerebras.ai/?utm_source=3pi_livekit\&utm_campaign=partner_doc)
* **OpenAI API Key** - Required for speech-to-text (Whisper). Get one at [OpenAI](https://platform.openai.com/api-keys)
* **LiveKit Account** - Visit [LiveKit Cloud](https://cloud.livekit.io/?utm_source=3pi_livekit\&utm_campaign=partner_doc) and create an account to get your API credentials
* **Python 3.11 - 3.13** - LiveKit agents require Python \< 3.14. Verify your version with `python --version`.

<Note>
  Cerebras provides ultra-fast LLM inference but does not currently offer speech-to-text (STT) models. This guide uses OpenAI's Whisper for STT and Cerebras for the LLM, giving you the best of both worlds.
</Note>

## Configure LiveKit with Cerebras

<Steps>
  <Step title="Create and activate a virtual environment">
    Set up an isolated Python environment for your project. This keeps dependencies organized and prevents conflicts with other projects.

    ```bash theme={null}
    python -m venv .venv
    source .venv/bin/activate  # On Windows: .venv\Scripts\activate
    ```
  </Step>

  <Step title="Install LiveKit agents and dependencies">
    Install the LiveKit agents framework with the necessary plugins. This includes OpenAI-compatible clients (which we'll use to connect to Cerebras), voice activity detection (VAD), and text-to-speech capabilities.

    ```bash theme={null}
    pip install 'livekit-agents[openai,silero,deepgram,cartesia,turn-detector]~=1.0' python-dotenv
    ```

    <Note>
      The `openai` plugin allows LiveKit to work with any OpenAI-compatible API, including Cerebras Inference.
    </Note>
  </Step>

  <Step title="Configure environment variables">
    Create a `.env` file in your project directory with your API credentials. These credentials authenticate your application with Cerebras, OpenAI, and LiveKit services.

    ```bash theme={null}
    CEREBRAS_API_KEY=your-cerebras-api-key-here
    OPENAI_API_KEY=your-openai-api-key-here
    LIVEKIT_URL=your-livekit-url-here
    LIVEKIT_API_KEY=your-livekit-api-key-here
    LIVEKIT_API_SECRET=your-livekit-api-secret-here
    ```

    Get your LiveKit credentials from the [LiveKit Cloud dashboard](https://cloud.livekit.io/):

    * **LIVEKIT\_URL**: Your project URL (starts with `wss://`)
    * **LIVEKIT\_API\_KEY** and **LIVEKIT\_API\_SECRET**: Generate these in Settings → Keys
  </Step>

  <Step title="Create a basic voice agent">
    Build a complete voice AI agent that uses OpenAI Whisper for speech-to-text and Cerebras for ultra-fast LLM responses.

    Create a file named `voice_agent.py`:

    ```python Server theme={null}
    import logging
    import os
    from dotenv import load_dotenv
    from livekit import agents, api
    from livekit.agents import AgentSession, Agent, RoomInputOptions
    from livekit.plugins import openai, silero

    load_dotenv()

    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger("voice-agent")

    CEREBRAS_URL = "https://api.cerebras.ai/v1"
    CEREBRAS_API_KEY = os.getenv("CEREBRAS_API_KEY")
    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

    LIVEKIT_API_KEY = os.getenv("LIVEKIT_API_KEY")
    LIVEKIT_API_SECRET = os.getenv("LIVEKIT_API_SECRET")
    LIVEKIT_URL = os.getenv("LIVEKIT_URL", "wss://cbrs-gk5k98e0.livekit.cloud")

    class Assistant(Agent):
        def __init__(self) -> None:
            super().__init__(instructions="You are a helpful voice AI assistant.")

    # Initialize OpenAI STT (Speech-to-Text) using Whisper
    stt = openai.STT(
        model="whisper-1",
        api_key=OPENAI_API_KEY
    )

    # Initialize Cerebras LLM for ultra-fast conversation
    llm = openai.LLM(
        model="gpt-oss-120b",
        api_key=CEREBRAS_API_KEY,
        base_url=CEREBRAS_URL,
        extra_headers={"X-Cerebras-3rd-Party-Integration": "livekit"}
    )

    async def entrypoint(ctx: agents.JobContext):
        logger.info(f"Starting agent in room {ctx.room.name}")
        session = AgentSession(
            stt=stt,
            llm=llm,
            tts=openai.TTS(), # Use OpenAI TTS
            vad=silero.VAD.load(),
        )
        await session.start(
            room=ctx.room,
            agent=Assistant(),
        )
        await session.generate_reply(
            instructions="Greet the user and offer your assistance."
        )

    if __name__ == "__main__":
        # Generate and display token
        if not LIVEKIT_API_KEY or not LIVEKIT_API_SECRET:
            print("Missing LIVEKIT_API_KEY or LIVEKIT_API_SECRET in .env file")
            print("Get these from your LiveKit Cloud dashboard: https://cloud.livekit.io/")
        else:
            token = api.AccessToken(LIVEKIT_API_KEY, LIVEKIT_API_SECRET) \
                .with_identity("test_user") \
                .with_grants(api.VideoGrants(
                    room_join=True,
                    room="test_room",
                ))
            
            jwt_token = token.to_jwt()
            
        print("\n\nLiveKit Agent Ready to Connect!\033[0m\n\033[94m" + "="*50 + "\033[0m")
        print(f"\033[94mConnect at: https://agents-playground.livekit.io/\033[0m\n\033[94m")
        print(f"\033[94mURL: {LIVEKIT_URL}\033[0m")
        print(f"\033[94mToken: {jwt_token}\033[0m" + "="*50 + "\033[0m")
        
        agents.cli.run_app(agents.WorkerOptions(entrypoint_fnc=entrypoint))
    ```

    <Note>
      This example uses OpenAI's Whisper for speech-to-text and OpenAI for text-to-speech, with Cerebras's `gpt-oss-120b` providing the ultra-fast intelligence.
    </Note>
  </Step>

  <Step title="Run and test your voice agent">
    Start your voice agent with the LiveKit CLI. The agent will connect to your LiveKit room and wait for a user to join.

    ```bash theme={null}
    python voice_agent.py dev
    ```

    To test your agent:

    1. Go to the [LiveKit Agents Playground](https://agents-playground.livekit.io/)
    2. **If authenticated**: You'll see available rooms and can join directly
       **Otherwise**: Use manual connection by entering the URL and token from your terminal (displayed in blue when you run the agent)
    3. Paste the token generated when running `python voice_agent.py dev`
    4. Click **Connect**
    5. **Approve microphone access** when Chrome prompts you (required for voice interaction)
    6. Speak into your microphone - the agent should respond!
  </Step>
</Steps>

## Example Use Cases

Combining LiveKit with Cerebras enables powerful real-time AI applications:

* **Multimodal Assistants** - Support text, voice, and screen sharing with an AI assistant that responds instantly.
* **Telehealth** - Enable real-time AI support during virtual medical consultations with HIPAA-compliant infrastructure.
* **Call Centers** - Automate inbound and outbound customer support with AI voice agents that handle multiple conversations simultaneously.
* **Real-time Translation** - Translate conversations instantly across languages with minimal latency.
* **Interactive Education** - Create voice-enabled tutoring systems that provide immediate feedback.
* **Voice Commerce** - Build conversational shopping experiences with natural voice interactions.

## Advanced Configuration

### Using Different Cerebras Models

You can easily swap models based on your needs. Choose faster models for lower latency or more capable models for complex reasoning tasks.

<CodeGroup>
  ```python Fast Response (gpt-oss-120b) theme={null}
  import os
  from livekit.plugins import openai

  CEREBRAS_URL = "https://api.cerebras.ai/v1"
  CEREBRAS_API_KEY = os.getenv("CEREBRAS_API_KEY")

  # For faster responses with smaller model
  llm = openai.LLM(
      model="gpt-oss-120b",
      api_key=CEREBRAS_API_KEY,
      base_url=CEREBRAS_URL,
      extra_headers={"X-Cerebras-3rd-Party-Integration": "livekit"}
  )
  ```

  ```python Balanced Performance (gpt-oss-120b) theme={null}
  import os
  from livekit.plugins import openai

  CEREBRAS_URL = "https://api.cerebras.ai/v1"
  CEREBRAS_API_KEY = os.getenv("CEREBRAS_API_KEY")

  # For balanced speed and capability
  llm = openai.LLM(
      model="gpt-oss-120b",
      api_key=CEREBRAS_API_KEY,
      base_url=CEREBRAS_URL,
      extra_headers={"X-Cerebras-3rd-Party-Integration": "livekit"}
  )
  ```

  ```python Maximum Capability (gpt-oss-120b) theme={null}
  import os
  from livekit.plugins import openai

  CEREBRAS_URL = "https://api.cerebras.ai/v1"
  CEREBRAS_API_KEY = os.getenv("CEREBRAS_API_KEY")

  # For most capable reasoning and responses
  llm = openai.LLM(
      model="gpt-oss-120b",
      api_key=CEREBRAS_API_KEY,
      base_url=CEREBRAS_URL,
      extra_headers={"X-Cerebras-3rd-Party-Integration": "livekit"}
  )
  ```
</CodeGroup>

## Available Models

LiveKit works with all Cerebras models for voice AI applications:

| Model            | Parameters | Best For                                                         |
| ---------------- | ---------- | ---------------------------------------------------------------- |
| **gpt-oss-120b** | 120B       | Largest model for the most demanding tasks                       |
| **zai-glm-4.7**  | 357B       | Advanced 357B parameter model with strong reasoning capabilities |

Change the `model` parameter in your LLM initialization to switch between models.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Agent not responding to voice input">
    **Check your microphone permissions** - Ensure your browser or application has access to your microphone.

    **Verify VAD settings** - The Silero VAD may need tuning for your audio environment. Try adjusting `min_speech_duration` and `min_silence_duration` parameters.

    **Test STT independently** - Make a direct API call to OpenAI Whisper to verify your audio is being transcribed correctly.
  </Accordion>

  <Accordion title="High latency in responses">
    **Use a smaller model** - Try `gpt-oss-120b` instead of `gpt-oss-120b` for faster responses. The 8B model typically responds 2-3x faster.

    **Check network connectivity** - Ensure stable connections to both LiveKit and Cerebras endpoints. Use `ping` and `traceroute` to diagnose network issues.

    **Optimize instructions** - Shorter, more focused system instructions lead to faster generation. Aim for instructions under 200 words.

    **Monitor token usage** - Longer conversations accumulate context. Consider implementing context window management to keep prompts concise.
  </Accordion>

  <Accordion title="Connection errors">
    **Verify API keys** - Double-check that your `CEREBRAS_API_KEY` and LiveKit credentials are correct and not expired.

    **Check base URL** - Ensure you're using `https://api.cerebras.ai/v1` for the Cerebras endpoint (note the `/v1` suffix).

    **Review firewall settings** - LiveKit requires WebRTC connections which may be blocked by some firewalls. Ensure UDP ports 50000-60000 are open.

    **Test connectivity** - Verify you can reach both services:

    ```bash theme={null}
    curl -H "Authorization: Bearer $CEREBRAS_API_KEY" https://api.cerebras.ai/v1/models
    ```
  </Accordion>

  <Accordion title="Audio quality issues">
    **Enable noise cancellation** - Configure noise cancellation in your `RoomInputOptions` if needed for noisy environments.

    **Check sample rates** - Ensure your audio input matches the expected sample rate for Whisper (16kHz). Mismatched sample rates can cause quality degradation.

    **Test TTS provider** - Try different TTS providers if Cartesia isn't meeting your quality needs. LiveKit supports multiple TTS engines including ElevenLabs and Deepgram.

    **Monitor bandwidth** - Poor audio quality can result from insufficient bandwidth. LiveKit automatically adjusts quality, but ensure you have at least 1 Mbps available.
  </Accordion>

  <Accordion title="Python version compatibility">
    **Verify Python version** - LiveKit agents require Python 3.11.5 or later. Check your version:

    ```bash theme={null}
    python --version
    ```

    **Use pyenv for version management** - If you need multiple Python versions:

    ```bash theme={null}
    pyenv install 3.11.5
    pyenv local 3.11.5
    ```

    **Check async compatibility** - Ensure you're using `async`/`await` syntax correctly. LiveKit agents are fully asynchronous.
  </Accordion>
</AccordionGroup>

<Warning>
  Remember to never commit your API keys to version control. Always use environment variables or secure secret management systems like AWS Secrets Manager or HashiCorp Vault.
</Warning>

## Next Steps

Now that you have a working voice agent, explore these advanced features:

* **Model Selection** - Try different [Cerebras models](/models) to optimize for speed vs. capability based on your use case.
* **Custom Frontend** - Build a custom client using the [LiveKit client SDKs](https://docs.livekit.io/realtime/?utm_source=3pi_livekit\&utm_campaign=partner_doc) for web, iOS, or Android.
* **Production Deployment** - Deploy your agent to production using [LiveKit Cloud](https://cloud.livekit.io/?utm_source=3pi_livekit\&utm_campaign=partner_doc) or self-hosted infrastructure.
* **Monitoring and Analytics** - Implement logging and monitoring to track agent performance and user interactions.
* **See how to use the latest GLM4.7 with Cerebras** - [GLM4.7 migration guide](https://inference-docs.cerebras.ai/resources/glm-47-migration?utm_source=3pi_livekit\&utm_campaign=partner_doc)

## Additional Resources

* [LiveKit Documentation](https://docs.livekit.io/?utm_source=3pi_livekit\&utm_campaign=partner_doc) - Complete guide to LiveKit features and APIs
* [LiveKit Agents GitHub](https://github.com/livekit/agents?utm_source=3pi_livekit\&utm_campaign=partner_doc) - Source code and examples
* [Cerebras API Reference](/api-reference/chat-completions) - Detailed API documentation
* [LiveKit Community](https://livekit.io/community?utm_source=3pi_livekit\&utm_campaign=partner_doc) - Get help from the LiveKit community
* [Example Applications](https://github.com/livekit/agents/tree/main/examples?utm_source=3pi_livekit\&utm_campaign=partner_doc) - Sample projects and use cases