reading-livekit-docs

$npx mdskill add expo/expo-livekit-template/reading-livekit-docs

LiveKit's SDKs change faster than model training data, so anything you remember about a LiveKit API, CLI flag, or default is a guess. Wrong guesses cost time: a wrong flag wastes a run, a wrong signature wastes a build.

SKILL.md

.github/skills/reading-livekit-docsView on GitHub ↗
---
name: reading-livekit-docs
description: 'Looks up current LiveKit facts (API signatures, CLI flags, config options, model and provider support, SDK changelogs, pricing) from the docs instead of answering from memory. Use whenever a question touches LiveKit specifics: "does LiveKit support X", "what changed in agents 1.8", "what are the arguments to Y", "how much does LiveKit cost", "find an example of Z in the LiveKit repos", or before writing any LiveKit code. Other LiveKit skills load this one first. Covers the LiveKit Docs MCP server and the `lk docs` CLI.'
license: MIT
metadata:
  author: livekit
---

# Reading LiveKit documentation

LiveKit's SDKs change faster than model training data, so anything you remember about a LiveKit
API, CLI flag, or default is a guess. Wrong guesses cost time: a wrong flag wastes a run, a wrong
signature wastes a build.

**Every LiveKit-specific fact you state or put in code should come from a lookup in this
session.** That includes facts you're confident about and patterns you've seen in other repos.

## Where to look, in order of preference

**1. The LiveKit Docs MCP server.** If its tools are in your session, use them. They're the same
source the CLI uses, with less friction.

**2. `lk docs`.** Available wherever the LiveKit CLI is installed, with no MCP setup. Use it when
the MCP tools aren't there; don't stop to ask the user to install anything first. It can search the
docs, fetch pages, search code across LiveKit's repositories, show an SDK's recent changelog, report
pricing, and submit feedback. Start with:

```bash
lk docs --help
lk docs search "agent simulations"
```

Once search has shown you the right page, fetch it. There's machine-readable output if you'd
rather parse than read.

**3. Web search against `docs.livekit.io`.** Only when neither of the above is available. Tell the
user you fell back to it, and mark generated code as unverified.

## How to research

- **Search before you read.** Search returns per-page excerpts, which is usually enough to pick the
  right page. Fetch full pages only once you know which one you need, or you'll fill the context
  window with pages you don't use.
- **Use code search for how, docs for what.** Docs tell you a parameter exists. LiveKit's own
  examples show how it's called. When a docs page and a working example disagree, go with the
  example and mention the discrepancy.
- **Use the changelog for version questions.** "Is X available yet", "when did Y change", and "why
  doesn't this argument exist" are answered by the changelog, not search.
- **Check the version you're on.** The installed SDK and CLI determine what works, and a documented
  feature may not exist in the installed version. For any CLI command, `--help` on the installed
  binary outranks every other source.

## Reporting what you found

- **Cite the page** when a decision rests on it, so the user can check you.
- **Say when you couldn't verify something.** "I could not confirm this signature against the docs"
  is useful to the user. A silent guess isn't.
- **Mark unverified code.** If you had to write LiveKit code without a lookup, add a comment at the
  call site saying it's unverified, and say so in your reply.
- **Don't invent a flag or parameter to make an example look complete.** An incomplete example with
  a note is better than a plausible fabrication.

## When the docs are wrong

Sometimes a page contradicts the SDK source or the CLI's `--help`. When that happens:

- **Go with what runs.** `--help`, the installed SDK's source, and a working example outrank a
  prose page. Tell the user which one you followed and why.
- **Report it** with the docs feedback command, and tell the user you did, so the next person
  doesn't hit the same error.

`lk docs` sometimes warns about version skew when the docs server is a little ahead of the CLI.
That's routine and the results are still good. Suggest updating `lk` and keep going.

## Related skills

- Building an agent: `building-livekit-agents`
- Live-testing one during development: `debugging-livekit-agents`
- Unit tests: `testing-livekit-agents`
- Simulations: `writing-livekit-scenarios`, `running-livekit-simulations`

More from expo/expo-livekit-template

SkillDescription
building-livekit-agentsBuilds voice and chat AI agents with LiveKit Agents and LiveKit Cloud. Use when the user asks to "build a voice agent", "create a LiveKit agent", "add voice AI to my app", "implement handoffs", "structure an agent workflow", "my agent is slow / too chatty", "it says it booked but nothing was saved", "make it confirm before committing", "it keeps re-asking things the caller already said", or is writing code against the LiveKit Agents SDK. Covers architecture: designing for latency, keeping context small, splitting a monolithic agent into handoffs and tasks, and designing for voice. Also covers keeping the model in charge of meaning while code owns state, approvals, and effects. For API specifics use reading-livekit-docs. To check behavior use debugging-livekit-agents and testing-livekit-agents.
debugging-livekit-agentsDrives a live multi-turn conversation with a LiveKit agent running locally, using `lk agent debugger`. Use when the user says "test my agent", "try my agent", "does this work", or "why did it call that tool", after editing an agent to check how it behaves, or when an agent on a speech-to-speech model or one that mishears users needs checking. The default for a bare "test"; for regression tests use testing-livekit-agents, for graded runs running-livekit-simulations.
operating-livekit-agentsDeploys and operates a LiveKit agent in production: shipping a version to LiveKit Cloud and rolling it back, secrets and configuration, the worker process model and prewarming, safe async inside worker processes, provider timeouts and degradation, graceful shutdown, SDK upgrades, and observability. Use when the user says "deploy my agent", "roll back the deployment", "tail the agent logs", "the first call after a restart is slow", "attached to a different loop / event loop is closed", "prewarm the VAD", "shut down without dropping calls", "upgrade livekit-agents safely", "correlate logs by session", or is changing an agent codebase that is already live. Not for designing the agent (building-livekit-agents) or reproducing one bad conversation locally (debugging-livekit-agents).
running-livekit-simulationsRuns LiveKit agent simulations and acts on the results. Use when the user says "run my simulations", "regression test my agent before deploying", "run the scenarios", "use lk agent simulate", "did my agent pass", "why did this scenario fail", "run simulations in CI", "test the audio pipeline", "check turn-taking and interruptions", or wants to check whole-conversation behavior before shipping. Covers text and audio mode and what each catches, running against a local or deployed agent, degraded-audio flags, automating a pre-release run, and triaging failures with list, view and export. For writing the scenarios use writing-livekit-scenarios. Not the default for a bare "test my agent", which goes to debugging-livekit-agents. Use this skill when the user names simulations, scenarios, a run, CI, or shipping.
testing-livekit-agentsWrites turn-level tests for a LiveKit agent in the user''s normal test suite: pytest (Python) or Vitest (Node.js). Use when the user asks to "write tests for my agent", "add a test for this tool", "test the handoff", "pin this bug", "why does my agent test fail", or after building or changing agent behavior that needs regression coverage. Covers the SDK''s test session harness, assertions on messages, tool calls and handoffs, LLM judging of a reply against an intent, mocking tools, multi-turn tests, and judging whole conversations with the built-in judges. For interactive poking use debugging-livekit-agents. For grading whole conversations at scale use running-livekit-simulations.
writing-livekit-scenariosCreates and maintains the scenarios a LiveKit agent simulation runs, and wires the agent to consume them. Use when the user asks "what should I test", "generate simulation scenarios", "write scenarios for my agent", "add a scenario for X", "organize my scenario files", "my simulations are flaky", "the scenario hits my real database", "seed state per scenario", "it passed but booked the wrong thing", "grade the final state", or wants to stress-test a flow before shipping. Covers generating a baseline with the LiveKit scenario generator and refining it, writing the cases generation misses, phrasing simulated-user instructions so they steer reliably, splitting scenarios into sets across files, and the agent-side code that seeds deterministic state from a scenario and fails a run on its final state. To run them use running-livekit-simulations.