agent.py

# Minimal voice-enabled Agent example (Python)
import logging
from dotenv import load_dotenv
from livekit.agents import AgentSession, JobContext, AgentServer, cli, inference
from livekit.plugins import silero

load_dotenv()
logger = logging.getLogger("livekit-agent")
logger.setLevel(<http://logging.INFO|logging.INFO>)

server = AgentServer()

def prewarm(proc):
    proc.userdata["vad"] = silero.VAD.load()

server.setup_fnc = prewarm

@server.rtc_session()
async def on_session(ctx: JobContext):
    <http://logger.info|logger.info>("Starting agent session")
    session = AgentSession(
        stt=inference.STT(model="deepgram/nova-2"),
        llm=inference.LLM(model="openai/gpt-4o"),
        tts=inference.TTS(model="cartesia/sonic-3"),
        vad=ctx.proc.userdata["vad"],
        preemptive_generation=True,
    )

    await session.start(ctx.room)
    await ctx.connect()
    await session.generate_reply(instructions="Greet the participant and ask how you can help.")

if __name__ == "__main__":
    cli.run_app(server)

LIVEKIT_API_KEY=your_api_key
LIVEKIT_API_SECRET=your_api_secret
LIVEKIT_URL=<wss://your-project.livekit.cloud>

pip install "livekit-agents[silero]" python-dotenv

python agent.py console

lk agent create --agent-file agent.py

None

session.chat_ctx.add_message()

session.generate_reply()

pip install "livekit-agents" python-dotenv

.env

LIVEKIT_API_KEY=your_api_key
LIVEKIT_API_SECRET=your_api_secret
LIVEKIT_URL=<wss://your-project.livekit.cloud>

# text_agent.py
import logging
from dotenv import load_dotenv
from livekit.agents import AgentServer, AgentSession, Agent, JobContext, cli, inference
from <http://livekit.agents.io|livekit.agents.io> import room_io

load_dotenv()
logging.basicConfig(level=<http://logging.INFO|logging.INFO>)
logger = logging.getLogger("text_agent")

server = AgentServer()

class TextOnlyAgent(Agent):
    def __init__(self):
        super().__init__(instructions="You are a helpful text-only assistant.")

    async def on_enter(self):
        # Optional greeting when the agent joins the room
        await self.session.say("Hello! I am a text-only assistant. How can I help you today?")

@server.rtc_session()
async def on_session(ctx: JobContext):
    <http://logger.info|logger.info>("Starting text-only agent session")

    # Create an AgentSession with no STT/TTS; use an LLM for responses
    session = AgentSession(
        stt=None,            # no speech-to-text
        tts=None,            # no text-to-speech
        llm=inference.LLM(model="openai/gpt-4o"),  # replace with your preferred model or remove
    )

    # RoomOptions to ensure no audio is used and text input/output enabled
    room_opts = room_io.RoomOptions(
        audio_input=False,
        audio_output=False,
        text_input=True,
        text_output=True,
    )

    # Start the session with the TextOnlyAgent
    await session.start(
        agent=TextOnlyAgent(),
        room=ctx.room,
        room_options=room_opts,
    )

    # Connect the agent to the LiveKit room
    await ctx.connect()

    # Keep running until the session ends
    await session.wait_until_closed()

stt=None

tts=None

room_io.RoomOptions

lk.chat

lk.transcription

session.say()

python text_agent.py console

lk.transcription

lk.chat

lk.transcription

lk.chat

lk.transcription

npm install livekit-client
# or with yarn
# yarn add livekit-client

import React, { useEffect, useState, useRef } from "react";
import { connect, Room, LocalTrackPublication } from "livekit-client";

export default function ChatRoom({ tokenUrl, roomName, userName }) {
  const [room, setRoom] = useState(null);
  const [connected, setConnected] = useState(false);
  const [messages, setMessages] = useState([]); // {sender, text, topic}
  const inputRef = useRef();

  // Helper to append message
  function pushMessage(sender, text, topic = "lk.chat") {
    setMessages((m) => [...m, { sender, text, topic, id: Date.now() + Math.random() }]);
  }

  // Connect to LiveKit on mount
  useEffect(() => {
    let r;
    async function init() {
      try {
        // Request a token from your server
        const resp = await fetch(`${tokenUrl}?room=${encodeURIComponent(roomName)}&name=${encodeURIComponent(userName)}`);
        const { token, url } = await resp.json(); // token and optional custom LiveKit url
        r = await connect(url || undefined, token, {
          // Avoid publishing audio/video for text-only client
          publishDefaults: { audio: false, video: false },
        });
        setRoom(r);
        setConnected(true);

        // Listen for incoming text streams
        r.on("textMessage", (msg, participant) => {
          // This event is for chat messages sent via the text API (legacy)
          // Some clients use explicit text streams; handle both.
          const sender = participant?.identity || msg.participantSid || "unknown";
          pushMessage(sender, msg.text || msg, "lk.chat");
        });

        // Register text stream handlers (for stream topics like lk.transcription)
        r.on("textStreamPublished", (stream, participant) => {
          // When a new text stream is published, attach a reader
          attachTextStream(stream, participant);
        });

        // Attach any existing text streams (in case agent already published)
        r.participants.forEach((p) => {
          p.getPublishedTextTracks?.()?.forEach((track) => attachTextStream(track, p));
        });

        // Local participant also may have text streams published
        r.localParticipant.getPublishedTextTracks?.()?.forEach((track) => attachTextStream(track, r.localParticipant));
      } catch (err) {
        console.error("connect error", err);
      }
    }
    init();

    return () => {
      if (r) r.disconnect();
    };
  }, [tokenUrl, roomName, userName]);

  // Attach text stream reader function
  async function attachTextStream(track, participant) {
    try {
      // livekit-client exposes a reader to consume text stream messages
      const reader = await track.createReader();
      (async () => {
        for await (const msg of reader) {
          // msg will be a string or object depending on publisher
          const text = typeof msg === "string" ? msg : JSON.stringify(msg);
          const sender = participant?.identity || "agent";
          const topic = track.topic || "lk.transcription";
          pushMessage(sender, text, topic);
        }
      })();
    } catch (e) {
      console.warn("failed to attach text stream", e);
    }
  }

  // Send a text message into the room (published to lk.chat)
  async function sendMessage() {
    if (!room) return;
    const text = inputRef.current.value.trim();
    if (!text) return;
    // Publish via LiveKit text message API
    // The livekit-client provides publishChatMessage
    try {
      room.localParticipant.publishChatMessage(text);
      pushMessage(userName, text, "lk.chat");
      inputRef.current.value = "";
    } catch (e) {
      console.error("send failed", e);
    }
  }

  return (
    <div style={{ maxWidth: 720, margin: "0 auto" }}>
      <h3>Text Chat Room: {roomName}</h3>
      <div style={{ border: "1px solid #ddd", padding: 12, height: 400, overflow: "auto" }}>
        {messages.map((m) => (
          <div key={m.id} style={{ marginBottom: 8 }}>
            <strong>{m.sender}</strong> <em style={{ color: "#666", fontSize: 12 }}>[{m.topic}]</em>
            <div>{m.text}</div>
          </div>
        ))}
      </div>

      <div style={{ marginTop: 8 }}>
        <input ref={inputRef} placeholder="Type a message..." style={{ width: "70%" }} onKeyDown={(e) => { if (e.key === "Enter") sendMessage(); }} />
        <button onClick={sendMessage} style={{ marginLeft: 8 }}>Send</button>
      </div>

      <div style={{ marginTop: 12 }}>
        <strong>Status:</strong> {connected ? "connected" : "disconnected"}
      </div>
    </div>
  );
}

tokenUrl

token

url

publishDefaults

room.localParticipant.publishChatMessage(text)

lk.chat

lk.transcription

lk.chat

textMessage

lk.transcription

lk.transcription

lk.transcription