vizio-tv
Click on "Install 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., "@vizio-tvturn on the TV"
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.
vizio-tv
MCP server to control a Vizio SmartCast TV over your local network. No cloud required — talks directly to the TV via the SmartCast local API.
Tools
Tool | Description |
| Initiate pairing — shows a PIN on the TV screen |
| Complete pairing with the PIN from the TV |
| Turn TV on, off, or toggle |
| Volume up, down, or mute (with optional step count) |
| Send any remote key (up, down, ok, back, home, play, pause, etc.) |
| Cycle to the next input source |
| Get current power and volume state |
Related MCP server: Smartest-TV
Setup
npm install
export VIZIO_IP=<your-tv-ip> # find in TV Settings > Network
node index.jsFind your TV's IP: Menu → Network → Manual Setup → IP Address
Pairing (one-time)
After starting the server, run pair_start — a 4-digit PIN appears on the TV. Then run pair_finish with that PIN. Auth token is saved to config.json (gitignored).
Add to Claude Code
{
"mcpServers": {
"vizio-tv": {
"command": "node",
"args": ["/path/to/vizio-tv/index.js"],
"env": { "VIZIO_IP": "<your-tv-ip>" }
}
}
}Available keys for send_key
power vol_up vol_down mute up down left right ok back exit home menu input play pause stop rewind fast_forward ch_up ch_down
Available Tools
7 toolschange_inputC
Switch to a different input on the TV
| Name | Required | Description | Default |
|---|---|---|---|
| steps | No | How many times to cycle the input |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description 'switch to a different input' is vague and does not disclose that the tool cycles through inputs (as implied by the 'steps' parameter). No annotations exist to compensate, leaving behavior ambiguous.
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 a single, concise sentence with no unnecessary words. However, it could be restructured to include key details without sacrificing brevity.
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?
Despite the tool's simplicity, the description lacks completeness by not explaining that input selection is cyclic. This omission could lead to incorrect agent behavior.
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 description adds no meaning beyond the schema for the 'steps' parameter. While schema coverage is 100%, the description omits any explanation of how the parameter affects input cycling, reducing its utility.
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 action ('switch to a different input') and resource ('TV'), making the purpose understandable. However, it does not differentiate from sibling tools like 'get_state' or 'volume', which operate on different aspects of the TV.
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?
No guidance is provided on when to use this tool versus alternatives. The description lacks context such as prerequisites (e.g., TV must be on) or exclusions (e.g., not for direct input selection).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_stateA
Get the current power and volume state of the TV
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden of disclosing behavior. It states the tool is a getter but does not mention whether it has side effects, requires authentication, or has rate limits. As a read operation, it is likely safe, but the lack of behavioral detail reduces transparency.
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 a single sentence that conveys the essential purpose without extraneous words. It is front-loaded and efficient, perfect for such a simple tool.
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?
Given the tool's simplicity (no parameters, no output schema), the description is mostly complete. However, it could mention the format of the returned state or whether it is a snapshot or polling data, but this is not critical.
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 and the input schema is empty, so the description does not need to explain parameter semantics. The baseline for no parameters is 4, and the description adequately implies no inputs are 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 explicitly states the tool retrieves the current power and volume state of the TV, clearly distinguishing it from sibling tools like 'power' and 'volume' which likely set these states. The verb 'Get' combined with the resource 'state' is specific and unambiguous.
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 implies the tool is for reading state, contrasting with sibling tools that perform actions (e.g., 'power', 'volume', 'send_key'). However, there is no explicit guidance on when to use this versus alternatives or what conditions might require a different approach.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pair_finishA
Complete pairing by entering the PIN shown on the TV
| Name | Required | Description | Default |
|---|---|---|---|
| pin | Yes | 4-digit PIN displayed on the TV screen |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations; description only says 'complete pairing' without disclosing prerequisites, side effects, or error conditions for a mutation action.
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?
Single sentence with no wasted words, front-loaded with action and key detail.
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?
Adequate for a simple one-param tool without output schema, but lacks context about the pairing flow or potential errors.
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?
Schema already describes '4-digit PIN displayed on the TV screen'; description adds no new meaning beyond stating the action.
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?
Description clearly states the tool completes pairing by entering a PIN shown on TV, distinguishing it from sibling pair_start which likely initiates pairing.
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?
Implies usage after starting pairing and seeing PIN, but no explicit when-not or alternatives to other sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pair_startA
Start pairing with your Vizio TV — a PIN will appear on screen
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must fully disclose behavioral traits. It only mentions that a PIN appears on screen, but does not address potential side effects (e.g., whether a previous pairing is overwritten), timeouts, or prerequisites. The tool's behavior beyond the PIN appearance is unclear.
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 a single sentence that front-loads the action and outcome. It is concise and every word contributes to understanding. No unnecessary information is present.
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?
The tool has no parameters and no output schema, so the description is nearly sufficient. It explains what happens (PIN appears), but could be improved by mentioning the need to complete pairing with 'pair_finish' and the PIN. Nonetheless, for a simple initiation tool, it is fairly complete.
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 no parameters and schema description coverage is 100%. Therefore the description does not need to add any parameter semantics. The baseline of 4 is appropriate since the description adds no extra information but none is required.
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 action 'Start pairing with your Vizio TV' and indicates the outcome 'a PIN will appear on screen'. It uses a specific verb and resource, making the purpose unambiguous. It also distinguishes itself from sibling tool 'pair_finish' by implying this is the initiation step.
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 implies when to use the tool (to start pairing), but does not explicitly state when not to use it or mention alternatives. With sibling 'pair_finish', there is no guidance on the sequence of operations. However, for a simple start action, the implied usage is acceptable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
powerB
Toggle TV power on or off
| Name | Required | Description | Default |
|---|---|---|---|
| action | No | toggle |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as idempotency, state assumptions, or side effects beyond the minimal toggle action.
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?
A single, front-loaded sentence with no wasted words; every part 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?
Given the tool's simplicity (one param, no output schema), the description is adequate but could be improved by mentioning scope (TV only) or prerequisite states.
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?
With 0% schema description coverage, the description fails to add meaning to the parameter; it only echoes the default action without explaining the enum values or their effects.
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 it toggles TV power on or off, with a specific verb and resource, distinguishing it from sibling tools like change_input or get_state.
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 implies when to use the tool (to control TV power), but provides no explicit guidance on when not to use it or alternatives, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
send_keyC
Send any remote key to the TV
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Key name to send | |
| repeat | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description does not disclose behavioral traits such as prerequisites, error handling, or side effects.
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?
Extremely concise (one sentence) but lacks valuable information; could be expanded to include usage guidance without becoming verbose.
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?
Incomplete for a tool with 2 parameters and no output schema; fails to explain return values, repeat behavior, or integration with siblings.
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?
Schema coverage is 50% and the description adds no meaning beyond the schema for either parameter; 'repeat' is not explained.
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 verb 'send' and the resource 'any remote key to the TV', distinguishing it from siblings like power and volume which are specific keys.
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?
No guidance on when to use send_key versus sibling tools like power or volume; no exclusions or context provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
volumeC
Adjust TV volume
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| steps | No | How many steps to adjust |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No behavioral details beyond the action name. Doesn't disclose side effects (e.g., mute toggling), reliance on TV state, or feedback. No annotations to compensate.
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?
Very concise at two words, but oversimplifies. Could be expanded to include usage context without becoming verbose.
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?
With no output schema and only half the parameters described, the description fails to cover basic behavioral aspects like whether volume wraps around or if mute is persistent.
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 'steps' parameter has a schema description explaining its purpose, but the 'action' enum lacks description. The tool description adds no additional meaning for either parameter.
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?
Clearly states the verb 'Adjust' and resource 'TV volume', making it distinct from siblings like change_input or power. However, it doesn't specify that it controls TV volume specifically, which is inferred but could be more explicit.
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?
No guidance on when to use this tool versus alternatives like send_key for volume. The description only states what it does, not when it's appropriate.
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. Dates show when Glama detected each change.
7 tool updates
v1.0.0- First observed
change_input - First observed
get_state - First observed
pair_finish - First observed
pair_start - First observed
power - First observed
send_key - First observed
volume
TDQS
Scored across 7 tools
Most tools have clear distinct purposes (e.g., power, volume, input). However, 'send_key' can duplicate functionality of other tools (e.g., power, volume) by sending the corresponding key, creating potential confusion.
All tools use a consistent snake_case naming convention (e.g., change_input, get_state, pair_finish). The pattern is uniform and predictable.
7 tools is an appropriate number for a TV remote control API, covering essential operations like power, volume, input switching, pairing, and generic key sending without being overly bloated.
Covers core TV control functions (power, volume, input, pairing, key sending). Missing a few features like getting current input or mute, but these are minor gaps for the stated purpose.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Control Android TV from any AI. 38 MCP tools: playback, recap, recommend, smart-home, schedules.
Full Spotify Web API coverage - albums, artists, playlists, player controls, and more.
Control a Loxone Miniserver smart home: lights, blinds, climate, scenes and energy.
Generate, edit, and render videos via the Shotstack video editing API.
Related MCP Servers
- AlicenseAqualityBmaintenanceProvides integrated control capabilities for LG ThinQ devices including status monitoring, device control, and profile information through a Model Context Protocol server.430Apache 2.0
- AlicenseAqualityAmaintenanceControl any smart TV with natural language — play Netflix/YouTube/Spotify by name, cast URLs, scene presets, multi-room audio, and multi-TV sync. Supports LG, Samsung, Android TV, Roku.2346MIT
- AlicenseAqualityDmaintenanceEnables discovery and control of Philips Hue lighting devices via a local bridge using the CLIP v2 API, without any cloud dependency.10MIT
- FlicenseAqualityDmaintenanceEnables AI assistants to control Roku TVs on the local network via natural language commands.6-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ryantorno-arch/mcp-vizio-tv'
If you have feedback or need assistance with the MCP directory API, please join our Discord server