livechat-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@livechat-mcpstart voice conversation with assistant"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
livechat-mcp
A Model Context Protocol (MCP) server that lets you have a continuous voice conversation with your AI coding assistant. You speak, your speech is transcribed locally with Whisper, and each utterance is delivered to the assistant as if you'd typed it. No tab switching, no copy/paste, no batch recording.
Demo
A short walkthrough of a live voice review session — talking to Claude Code about a weather dashboard, no typing involved. Recorded with my own (non-native English) accent, to show transcription holds up across speakers.

A few things people use it for:
Live-reviewing a vibe-coded feature. Walk through the diff and narrate fixes as you spot them — the assistant edits in place while you keep reading.
Stream-of-consciousness debugging. Speak your hypotheses out loud as you investigate; the assistant tries them, reports back, you keep moving.
Hands-free note-taking with project context. "Add a TODO that the auth middleware needs a rate-limit step", said while looking at the file — lands as a real comment in the right spot.
Pair-programming while you're not at the keyboard. Eating, on a walk with AirPods, sketching on paper — keep the conversation going.
Onboarding a new repo. Talk through what you're seeing as you read; the assistant answers questions and pulls up related code without you losing your place.
Works with any MCP host. First-class support for:
Claude Code
Codex CLI
Gemini CLI
Related MCP server: Voice MCP
Requirements
Tested on macOS only so far. Linux and Windows are wired up in code (install scripts, mic-permission notes, locking primitives) but haven't been independently verified yet — bug reports welcome.
macOS, Linux, or Windows (native via PowerShell, or under WSL2 / Git Bash).
Python 3.10+
An MCP host installed (Claude Code, Codex, Gemini, etc.)
A working microphone
~500 MB disk for Whisper model cache + dependencies
uvfor project management (recommended)
Quick install (recommended)
One command — no clone needed.
macOS / Linux / Git Bash on Windows:
curl -LsSf https://raw.githubusercontent.com/brunocramos/livechat-mcp/main/bootstrap.sh | bashNative Windows PowerShell:
irm https://raw.githubusercontent.com/brunocramos/livechat-mcp/main/bootstrap.ps1 | iexThe bootstrap clones the repo to ~/.local/share/livechat-mcp (override
with $LIVECHAT_INSTALL_DIR) and runs install.sh / install.ps1, which
installs portaudio if needed (brew / apt / dnf / pacman / zypper — Windows
wheels ship it bundled), installs uv if missing, runs uv sync, drops the
wizard into ~/.local/bin, and launches the interactive setup wizard.
If you've already cloned the repo manually, run ./install.sh (or
.\install.ps1) directly and skip the curl step.
First-run permissions. Two prompts to expect, both one-time:
OS mic access, the first time
/livechatopens the microphone (macOS: a System Settings dialog; Windows: the Privacy & Security panel; Linux: usually nothing if your user is in theaudiogroup).MCP tool approvals from your assistant CLI — Claude Code / Codex / Gemini will ask once per tool the first time it's invoked (
get_voice_input,end_voice_session,reset_voice_session,take_over_voice_session). Approve "always" and they won't ask again.After both, every subsequent session is hot the moment you say go.
Windows: native locking uses
msvcrtand takeover signaling is file-based, so nofcntldependency. The interactive wizard is a bash script —install.ps1invokes it through Git Bash, which it offers to install viawingetif missing.
Manual setup
If you'd rather install step-by-step, here's what install.sh does:
1. Install portaudio
sounddevice needs portaudio.
macOS:
brew install portaudioDebian/Ubuntu:
sudo apt-get install libportaudio2 portaudio19-devFedora/RHEL:
sudo dnf install portaudio portaudio-develArch:
sudo pacman -S portaudio
2. Install uv if you don't have it
curl -LsSf https://astral.sh/uv/install.sh | sh3. Clone and install dependencies
cd livechat-mcp
uv syncThis will create .venv/ and install mcp, faster-whisper, sounddevice,
silero-vad, torch, etc.
4. Run the setup wizard
install -m 0755 bin/livechat-mcp ~/.local/bin/livechat-mcp
livechat-mcp setupThe wizard will:
Ask which assistants to install for (Claude Code / Codex / Gemini, any combination).
Copy the
/livechatand/endlivechatslash commands to hosts that support custom slash commands. For Codex, it installs both legacy prompt files and alivechatskill, because current Codex CLI releases do not expose custom prompts as/livechat.Register the MCP server in each host's config file.
Walk you through the tunable env vars (silence threshold, Whisper model, etc.) — press Enter to keep defaults.
Make sure ~/.local/bin is on your PATH (it already is if you used the
official uv installer).
If you'd rather wire things up by hand, the manual steps for each host are below.
5. Grant microphone permission
macOS: the first time the server tries to capture audio, macOS will prompt your terminal app (Terminal, iTerm, Ghostty, Warp, etc.) for mic access. If you miss the prompt, enable it manually:
System Settings → Privacy & Security → Microphone → enable for your terminal
If you skip this, audio capture silently returns silence and nothing will ever transcribe.
Windows: Settings → Privacy & security → Microphone → allow desktop apps to access the microphone (and ensure your terminal is permitted).
Linux: usually no prompt — just make sure your user has the right ALSA / PulseAudio / Pipewire access (typically the
audiogroup).
6. Pre-download the Whisper model (optional)
The first run downloads base.en (~150 MB). You can pre-warm it:
uv run python -c "from faster_whisper import WhisperModel; WhisperModel('base.en', device='cpu', compute_type='int8')"Manual install (skip if you used livechat-mcp setup)
Claude Code
Copy the slash commands:
mkdir -p ~/.claude/commands
cp commands/livechat.md ~/.claude/commands/
cp commands/endlivechat.md ~/.claude/commands/Register the MCP server:
claude mcp add livechat -- uv --directory "$(pwd)" run livechat-mcpOr edit ~/.claude.json directly:
{
"mcpServers": {
"livechat": {
"command": "uv",
"args": ["--directory", "/absolute/path/to/livechat-mcp", "run", "livechat-mcp"]
}
}
}Codex CLI
Install the Codex skill and legacy prompt files:
mkdir -p ~/.codex/skills/livechat
cp skills/livechat/SKILL.md ~/.codex/skills/livechat/
mkdir -p ~/.codex/prompts
cp commands/livechat.md ~/.codex/prompts/
cp commands/endlivechat.md ~/.codex/prompts/Register the MCP server in ~/.codex/config.toml:
[mcp_servers.livechat]
command = "uv"
args = ["--directory", "/absolute/path/to/livechat-mcp", "run", "livechat-mcp"]Gemini CLI
Gemini uses TOML for custom commands. The wizard generates these for you;
to do it by hand, see commands/gemini/livechat.toml.template (created by
running livechat-mcp setup once).
Register the MCP server in ~/.gemini/settings.json:
{
"mcpServers": {
"livechat": {
"command": "uv",
"args": ["--directory", "/absolute/path/to/livechat-mcp", "run", "livechat-mcp"]
}
}
}Usage
Open your assistant's CLI in any terminal:
claude # or: codex or: geminiThen in the assistant prompt:
/livechat # Claude Code, Gemini CLI
use livechat # Codex CLICodex restart required. Codex only loads skills and MCP servers at startup. If you ran the wizard while Codex was open, quit and relaunch before using
use livechat.
Codex 0.128.0 does not support user-defined /livechat slash commands; / is
currently reserved for Codex's built-in commands. The setup installs a
discoverable livechat skill instead, so you can type use livechat or open
/skills and pick livechat.
The assistant will call get_voice_input and start listening. Speak
normally. When you pause for ~1.5 seconds, your utterance is finalized,
transcribed, and sent as a prompt. The assistant responds, then immediately
listens for the next utterance.
While the assistant is generating a response, the mic is still hot — anything
you say during that time queues up and is delivered all at once on the next
get_voice_input call.
Ending a session
Three ways:
/endlivechat— cleanest, runs from the assistant prompt. (You'll need to interrupt the current turn first if it's mid-response.)Wake phrase — say
terminate voice session now. The transcription triggers shutdown. The phrase is intentionally awkward to avoid collisions with real review content. Configurable viaLIVECHAT_END_PHRASE.Ctrl+C — kills the MCP server. The assistant will see a tool error on the next call and stop the loop.
Configuration
All tunables live in livechat_mcp/config.py and can be overridden via env vars:
Var | Default | Notes |
|
| English-only: |
|
| Language code ( |
|
|
|
|
|
|
|
| Silence after speech to end an utterance |
|
| Silero VAD speech probability threshold |
|
| Minimum utterance length (filters coughs) |
|
| Force-cut runaway utterances |
|
| How long |
|
| Spoken phrase to end the session |
| unset | Set to |
The easy way to set these is livechat-mcp set KEY VALUE — it edits the
env block in every host config it finds (Claude / Codex / Gemini).
livechat-mcp show # print current env block(s)
livechat-mcp set LIVECHAT_SILENCE_SEC 1.5
livechat-mcp unset LIVECHAT_DEBUGRestart your assistant CLI after any change — MCP env vars are read by the server at startup.
To do it manually, edit the env field of the livechat MCP entry in each
host's config. Example for Claude Code:
{
"mcpServers": {
"livechat": {
"command": "uv",
"args": ["--directory", "/abs/path", "run", "livechat-mcp"],
"env": {
"LIVECHAT_WHISPER_MODEL": "small.en",
"LIVECHAT_DEBUG": "1"
}
}
}
}Troubleshooting
Nothing happens when I speak.
Check (in order): mic permission for your terminal app, mic input level
(System Settings → Sound), set LIVECHAT_DEBUG=1 and watch stderr for VAD
events, lower LIVECHAT_VAD_THRESHOLD to 0.3.
Transcriptions are inaccurate.
Upgrade model: LIVECHAT_WHISPER_MODEL=small.en or medium.en. medium.en
is noticeably slower on CPU (still real-time-ish) but much better for
technical vocabulary.
Utterance ends too quickly / too slowly.
Tune LIVECHAT_SILENCE_SEC (or run livechat-mcp set LIVECHAT_SILENCE_SEC 1.5).
1.0–4.5 is the useful range — lower feels snappier but risks cutting
mid-thought pauses.
uv not found.
Either install uv (recommended) or change the MCP config command to a
direct invocation of python -m livechat_mcp.server from inside an activated
venv.
The server starts but the assistant never calls the tool.
Make sure /livechat was invoked. Without the slash command, the assistant
has no instruction to enter the loop.
Server logs go into the assistant's UI as garbage / break the protocol.
This shouldn't happen — all server logging goes to stderr. If you see it,
file a bug. Make sure you have not added any print(...) statements without
file=sys.stderr.
portaudio errors on startup.
Install it: brew install portaudio. If it's installed and still failing, try
brew reinstall portaudio and reinstall sounddevice: uv sync --reinstall.
How it works (short version)
[mic] → [Silero VAD] → [Whisper] → [queue] ← [get_voice_input tool] ← [Assistant]
↑________background thread, always running________↑The audio pipeline is decoupled from the MCP tool, so the mic is always hot while the server is up. Utterances spoken while the assistant is generating a response are queued and delivered on the next tool call.
License
MIT.
Available Tools
4 toolsend_voice_sessionA
Cleanly end the current voice session. After calling this, any further get_voice_input calls will return 'END_SESSION'. Use this when the user invokes /endlivechat or otherwise asks to stop voice mode.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It discloses the key side effect: subsequent get_voice_input calls return '__END_SESSION__'. It doesn't mention idempotency or error conditions, but for a zero-parameter tool this is sufficient disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the main action, then the effect and trigger. No wasted words, perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, no-output-schema tool, the description covers purpose, usage, and behavioral consequence. An agent has everything needed to decide when to call and what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the baseline is 4. The description correctly adds no parameter info, and none is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Cleanly end the current voice session.' It uses a specific verb (end) and resource (voice session), and the mention of the sentinel return on get_voice_input distinguishes it from siblings like take_over_voice_session or reset_voice_session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit usage guidance: 'Use this when the user invokes /endlivechat or otherwise asks to stop voice mode.' This clearly tells the agent when to invoke this tool versus the alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_voice_inputA
Returns the next voice utterance from the user as text. Used in a loop during voice review sessions. If multiple utterances are queued, they are joined with ' / '. Returns the literal string 'END_SESSION' when the user has ended the session (Ctrl+C, /endlivechat, or wake phrase) — stop calling this tool when you see that. Returns 'NO_INPUT' if the long-poll timed out with no speech; in that case, call this tool again. Returns 'ALREADY_RUNNING:' if another livechat MCP process (e.g. another Claude Code window) currently holds the session lock — ask the user to confirm a takeover, then call take_over_voice_session if they agree.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully carries the behavioral disclosure burden. It reveals long-poll timeout behavior, queue joining with ' / ', sentinel values, the session lock with PID, and the exact follow-up action for each sentinel. This is exceptionally transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is longer than most, but every sentence earns its place: purpose, loop context, queue joining, and each sentinel case. It is well-structured, front-loaded with the core purpose, and groups related behavioral details logically.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, but the description documents every possible return value and the appropriate agent reaction, including edge cases like concurrent process lock and takeover. It also names the relevant sibling tool. No meaningful gaps remain for an agent to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters)Skip, so the schema is trivially complete (100% coverage). The description adds no parameter details, but none are needed; the baseline for a zero-parameter tool is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Returns the next voice utterance from the user as text.' It clearly frames the tool as a polling operation used in a loop during voice review sessionsasha. The sentinel behaviors and the mention of take_over_voice_session distinguish it from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly explains when to call the tool (in a loop during voice review) and how to react to each possible return value: retry on __NO_INPUT__, stop on __END_SESSION__, and ask the user then call take_over_voice_session on __ALREADY_RUNNING__. This is clear, actionable usage guidance with no ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
reset_voice_sessionA
Clear stale shutdown state from a previous /endlivechat in this same MCP server process so a new voice session can start cleanly. Call this once at the very beginning of a /livechat session, after the announcement and before the first get_voice_input. Safe to call mid-session: if a session is already running healthily this is a no-op and no in-flight utterances are dropped.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It discloses that it clears stale state, is a no-op on a healthy session, and explicitly guarantees 'no in-flight utterances are dropped'. These behavioral details are specific and transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each earning its place: purpose and state, exact placement in the session flow, and safety guarantee. No redundancy, front-loaded with the primary action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter utility tool with no output schema, the description covers purpose, timing, safety, and idempotency. It provides all necessary context for an agent to decide when and how to call it, and it clearly differentiates from sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema is empty and description coverage is trivially 100%. The baseline for zero-parameter tools is 4; the description appropriately says nothing about parameters since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Clear'), a resource ('stale shutdown state'), and the purpose ('so a new voice session can start cleanly'). It clearly differentiates from siblings by placing the call before get_voice_input, making its role obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs when to call: 'at the very beginning of a /livechat session, after the announcement and before the first get_voice_input'. It also notes it is safe mid-session and is a no-op if the session is healthy, giving clear usage conditions without ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
take_over_voice_sessionA
Forcibly take the cross-process session lock from another livechat MCP instance. Signals the holder to release, waits briefly, and starts a new session here. Only call this after the user explicitly confirms taking over from the other window. Returns 'OK' on success or an error string on failure.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the full behavioral disclosure burden. It fully discloses the mechanism: the tool signals the current holder to release, waits briefly, starts a new session, and returns 'OK' or an error string. This gives the agent enough detail to anticipate side effects and outcomes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three tight sentences with no filler. The first sentence names the action and target, the second explains the process, and the third adds the safety condition and expected return value. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description is complete: it explains what happens, when to call it, and what the response will be. Nothing essential is missing for an agent to invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline is 4. The description correctly adds no parameter details because none exist, and it still clarifies the operational scope and return behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('take') and resource ('cross-process session lock from another livechat MCP instance'), making the action unmistakable. It also differentiates this tool from siblings like get_voice_input or end_voice_session by focusing on the takeover of a lock rather than reading or ending a session.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when the tool is appropriate: 'Only call this after the user explicitly confirms taking over from the other window.' This is a clear, actionable condition that prevents premature or accidental invocation, and it implies the alternative context (continue using the current instance) without needing to name a sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v0.1.0- First observed
end_voice_session - First observed
get_voice_input - First observed
reset_voice_session - First observed
take_over_voice_session
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: retrieving input, ending the session, taking over a lock, and resetting state. No overlap or ambiguity between them.
All tool names follow a consistent verb_noun snake_case pattern (e.g., get_voice_input, end_voice_session). The pattern is uniform and predictable.
Four tools is well-scoped for a voice session lifecycle. Each tool serves a necessary function with no redundancy, fitting the server's narrow purpose.
The tool surface covers the full voice session lifecycle: starting clean, retrieving input, ending, and handling cross-process takeover. No obvious dead ends or missing operations for the intended use case.
Maintenance
Related MCP Connectors
Speech, transcription, voice agents, Trace, Recap, dubbing and narration with browser OAuth.
Transcribe audio & video to text for AI agents: 100+ languages, speaker labels, webhooks.
- ChamadeOAuthio.chamade
Voice and chat for AI agents — Discord, Teams, Meet, Slack, Zoom, Telegram, WhatsApp, NC Talk, SIP
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Related MCP Servers
- FlicenseNot gradedqualityCmaintenanceEnables coding agents to speak aloud using text-to-speech functionality. Works with agents running inside devcontainers and provides configurable voice settings for creating chatty AI companions.4-
- FlicenseNot gradedqualityDmaintenanceEnables voice interaction with Claude Code through local speech-to-text (Whisper) and text-to-speech (Supertonic), allowing verbal input/output without external API calls.1-
- FlicenseNot gradedqualityCmaintenanceEnables natural voice interaction with Claude Code through speech-to-text, supporting wake word activation and multiple backends like Whisper and Google. It allows users to execute commands and control their coding environment hands-free via their microphone.2-
- AlicenseNot gradedqualityDmaintenanceEnables bidirectional voice interaction for Claude Code using local speech-to-text and text-to-speech models optimized for Apple Silicon. It provides tools to listen to user speech via microphone and speak responses aloud through system speakers.16Apache 2.0