LiveKit Real-Time Rooms MCP for AI. Control participant feeds and manage full voice/video sessions.

Q: How do I make sure data gets delivered using senddata?

You specify the delivery mode when calling senddata. Use "reliable" if you absolutely must guarantee the message gets through, or use "lossy" for messages where speed is more important than perfect receipt.

Q: removeparticipant revokes their access token automatically?

Yes. When your agent runs removeparticipant, it handles the cleanup by revoking the user's token, ensuring they can't rejoin using old credentials.

Q: Does updating metadata require knowing every single participant ID?

No. For general room status changes, you use updateroommetadata. If you only need to change one person's details, use getparticipant first to confirm the ID and then run updateparticipantmetadata.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

LiveKit Real-Time Rooms MCP Server manages voice and video room lifecycles. Use this server to programmatically create, delete, and list rooms.

You can control participants—like muting tracks or removing users—and broadcast data payloads to everyone in the session from your AI client.

What your AI can do

Create room

Creates a new LiveKit room using specified parameters and access tokens.

List rooms

Lists all active rooms running on the entire LiveKit server instance.

Delete room

Deletes an active room, ensuring all connected participants are disconnected.

+ 7 more capabilities included

Provision Rooms

Create and delete voice/video rooms using create_room or delete_room.

Manage Users in Sessions

List, inspect, remove participants, and update user metadata with tools like list_participants, get_participant, and update_participant_metadata.

Moderate Audio/Video Feeds

Control live content streams by muting or unmuting a participant's specific audio or video track using mute_track.

Broadcast State Data

Send targeted data messages to every person in the room with guaranteed or lossy delivery via send_data.

Control Room Settings

Update core room information, like timeouts or session names, using update_room_metadata.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

LiveKit Real-Time Rooms: 10 Tools for Session Control

These tools let you manage the entire lifecycle of a real-time voice or video session—from setup to moderation and teardown.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using LiveKit Real-Time Rooms on Vinkius

Create Room

Creates a new LiveKit room using specified parameters and access tokens.

List Rooms

Lists all active rooms running on the entire LiveKit server instance.

Delete Room

Deletes an active room, ensuring all connected participants are disconnected.

Get Participant

Retrieves detailed information about a specific participant currently in a room.

List Participants

Generates a list of every user currently connected to the specified room.

Mute Track

Silences or reactivates a participant's published audio or video stream for moderation purposes.

Remove Participant

Forces a participant out of a room and revokes their associated access token.

Send Data

Broadcasts a data message to all participants in a room, choosing between reliable...

Update Participant Metadata

Changes the metadata associated with an individual participant's account within the...

Update Room Metadata

Modifies structured data that applies to the entire room session.

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The LiveKit Real-Time Rooms integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "tt-voice": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the LiveKit Real-Time Rooms tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"tt-voice": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with LiveKit Real-Time Rooms, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

LiveKit Real-Time Rooms MCP server cover

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by LiveKit. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Checking who is in a meeting shouldn't take 10 clicks.

Today, checking room status means jumping between participant lists, clicking on users one by one to check their roles, and hoping the dashboard hasn't timed out. It’s manual, slow, and relies on a perfect UI state that often breaks.

With this MCP, you call `list_participants` and get an immediate list of everyone in the room. Your agent knows exactly who is present without navigating any dashboards—it just gives you the raw data.

Using LiveKit Real-Time Rooms MCP Server: Control sessions with action.

Manual processes include setting up a room, waiting for users to connect, and then manually adjusting moderation settings if something goes wrong. It's reactive, requiring human intervention at key moments.

Now, your agent handles it all. You call `create_room` to set boundaries, wait for events, and when necessary, run `mute_track` or `send_data`. The whole process runs as code.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

This MCP gives your AI client direct control over live voice and video sessions running on LiveKit. You're not just connecting; you're managing the entire lifecycle of a room from start to finish. It lets your agent act like a dedicated session operator, controlling everything programmatically without needing to touch an actual dashboard.

Room Provisioning & Discovery
You can manage the existence of rooms using create_room, which provisions a brand new LiveKit room based on specific parameters and requires access tokens. If you need to shut down an active session, delete_room handles it by immediately disconnecting every participant currently in that space. To see what's running, you use list_rooms; this tool gives you a full rundown of all active rooms across the entire LiveKit server instance.

Participant and User Management
The tools let you track who's connected and control their session state. You can pull up an inventory of everyone in a room using list_participants, which generates a list of every single user currently logged in. If you need deep details on just one person, get_participant retrieves all the specific information associated with that individual participant inside the room.

When you decide to enforce removal, remove_participant forces an exit, revoking the user's access token and kicking them out of the session. You can also modify the data attached to a specific person by using update_participant_metadata, letting you change the structured information tied to their account within that room.

Session Moderation & Control
When moderation is necessary, you've got mute_track. This function allows you to silence or reactivate a participant’s specific published audio feed or video stream. For controlling core session settings—like timeouts or the formal name of the room itself—you use update_room_metadata to modify structured data that applies universally across the entire room environment.

Data Broadcasting & State UpdatesIn terms of communication, you've got two main mechanisms. First, you can send a targeted message to every person in the room using send_data. This tool lets you choose between reliable delivery, ensuring the message gets through even if there are network hiccups, or lossy delivery for less critical status updates.

Summary of Mechanisms

Creating and Deleting Rooms: You use create_room to spin up a session and delete_room to terminate it.
Listing Rooms: list_rooms gives you the global view of all active sessions.
Checking Users: list_participants generates an immediate roster, while get_participant dives deep into a single user's specific data points.
Controlling Users: You can enforce removal with remove_participant, or update their profile details using update_participant_metadata.
Managing Streams: mute_track lets you control live audio and video feeds for moderation purposes.
Broadcasting State: send_data pushes messages to everyone, choosing whether they need guaranteed delivery or if a lossy update is fine.
Setting Data: You use update_room_metadata to adjust the core data structure of the room itself.

Built · Hosted · Managed by Vinkius LiveKit Real-Time Rooms MCP Server - Control Voice/Video Sessions

Server ID 019d8493-5ed6-70ce-a2e1-4a6b71882ce6

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Here's how it actually works

The bottom line is, your AI client treats real-time room management like calling a function: input parameters, get guaranteed results.

Your AI client calls a tool (e.g., create_room) and passes necessary parameters.

The MCP server executes the corresponding LiveKit API call to manage the room state on the backend.

The server returns a status confirmation or the requested data payload (e.g., a list of participants).

Who is this actually for?

This server is for developers building systems that need to control live communication streams. If you're the developer who has to manually script meeting setup or moderation actions, this saves hours of boilerplate code. It’s built for complex agent workflows.

AI Agent Developer

Uses create_room and send_data to manage conversational sessions where the AI needs to dynamically start, control, and end a call.

Video Platform Architect

Automates room provisioning and participant lifecycles across multiple services, relying on list_rooms and remove_participant.

Live Event Operator (Automation)

Builds automated moderation tools that use mute_track or check metadata with get_participant during a live broadcast.

What Changes When You Connect

Automate moderation instantly. Instead of manually muting streams, your agent runs mute_track to enforce content policies in real-time.

Maintain session state perfectly. Use update_room_metadata to ensure all participants see the latest room status (like 'Meeting Topic: Q3 Budget').

Control who's present. With list_participants, your agent can check occupancy before starting a call, and use remove_participant if someone misbehaves.

Guarantee data transfer. Use send_data to broadcast critical updates (e.g., 'Session paused') with guaranteed or low-latency delivery modes.

Manage the entire lifecycle. You can build complex flows using create_room and ensure cleanup by calling delete_room when the session ends.

See it in action

01 01

Automated Onboarding Call Setup

A sales agent needs to set up a demo call. The agent first calls create_room with specific limits. Once users join, the agent uses update_participant_metadata for each person (e.g., setting 'Role: Prospect') so that later tools can reference their correct identity.

02 02

Real-Time Moderation During Broadcast

A live stream detects inappropriate content. The agent immediately calls mute_track on the offending user's feed. If they persist, the agent escalates by running remove_participant, ensuring clean session management.

03 03

Group Status Broadcasting

In a large conference room setup, the moderator needs to announce key milestones. They use send_data to send a broadcast message (e.g., 'Break in 5 minutes') that all participants receive reliably.

04 04

Audit and Cleanup

When a meeting ends, the agent first uses list_participants to verify everyone has left. Then, it calls delete_room to clean up the session resources entirely, preventing stale room records.

The honest tradeoffs

Assuming state is persistent

Anti-pattern

Trying to check who was in a meeting an hour ago by just listing rooms. The data is transient and only reflects current connections.

The Fix

If you need historical records, you must implement external logging. For current status checks, use list_participants on the room ID for real-time accuracy.

Ignoring participant identity

Anti-pattern

Sending a data update without knowing who it applies to. You might accidentally target the wrong user or lose context.

The Fix

Always use get_participant first to confirm metadata and IDs, then apply targeted changes using update_participant_metadata.

Over-relying on room name

Anti-pattern

Assuming a room name is enough to identify all participants or settings. Names can change, and the state needs explicit refreshing.

The Fix

Rely on structured data access: use list_rooms for names, but always verify current participant lists via list_participants.

When It Fits, When It Doesn't

Use this server if your application logic requires programmatic control over a live communication channel. Specifically, if you need to perform moderation (like muting tracks), manage user presence (remove_participant), or broadcast real-time data payloads that aren't just chat text.

Don't use it if all you need is simple one-way messaging between two users—a basic message queue system might suffice. If your primary goal is storing historical conversation transcripts, this MCP won't help; you need a dedicated database connector. Use this only when the session state itself is the critical resource to manage.

Questions you might have

Can I use the `list_rooms` tool with LiveKit Real-Time Rooms MCP Server? +

Yes, you can. It lists all active rooms on your server instance, which is useful for auditing or finding a specific room ID to target later.

How do I make sure data gets delivered using `send_data`? +

You specify the delivery mode when calling send_data. Use "reliable" if you absolutely must guarantee the message gets through, or use "lossy" for messages where speed is more important than perfect receipt.

`remove_participant` revokes their access token automatically? +

Yes. When your agent runs remove_participant, it handles the cleanup by revoking the user's token, ensuring they can't rejoin using old credentials.

Does updating metadata require knowing every single participant ID? +

No. For general room status changes, you use update_room_metadata. If you only need to change one person's details, use get_participant first to confirm the ID and then run update_participant_metadata.

What parameters can I set when using the `create_room` tool? +

You define timeouts and participant limits in the request. This lets you control how long a room stays open or how many people can join, which is key for managing session scope.

How does `get_participant` help me verify who is currently active? +

You pass the participant's ID to this tool. It returns detailed info—like their current status and metadata—so you don't have to list everyone just to check one person.

Can I use `mute_track` if a user hasn't started broadcasting audio or video? +

No. You must first confirm the participant is publishing an active track before calling mute_track. Otherwise, the API call will fail because the resource doesn't exist.

Is updating metadata via `update_participant_metadata` safe for other profile data? +

Yes. This tool only touches the participant's stored metadata fields. It won't change their username, display name, or general connection status.

Can I list all active rooms on my LiveKit server? +

Yes! Use the list_rooms tool. It calls the LiveKit RoomService ListRooms endpoint and returns all currently open rooms with their participant count, metadata, and creation time.

How do I mute a participant's microphone? +

First use list_participants to get the track SID for the participant's audio track. Then call mute_track with the room name, participant identity, track SID, and muted set to 'true'.

Does this work with self-hosted LiveKit servers? +

Yes! Just provide your self-hosted server's URL (e.g., https://livekit.yourserver.com) as the Host URL, along with the API Key and Secret from your server's config.yaml.

Connect to your AI in seconds.

Create room

List rooms

Delete room

LiveKit Real-Time Rooms: 10 Tools for Session Control

Make your AI actually useful.

Create Room

List Rooms

Delete Room

Get Participant

List Participants

Mute Track

Remove Participant

Send Data

Update Participant Metadata

Update Room Metadata

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Checking who is in a meeting shouldn't take 10 clicks.

Using LiveKit Real-Time Rooms MCP Server: Control sessions with action.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Automated Onboarding Call Setup

Real-Time Moderation During Broadcast

Group Status Broadcasting

Audit and Cleanup

The honest tradeoffs

Assuming state is persistent

Ignoring participant identity

Over-relying on room name

When It Fits, When It Doesn't

Questions you might have