Provides tools to monitor and control your Tesla Powerwall 2 system locally via the gateway API, including authentication, real-time power metrics, battery state, system status, operation mode changes, and configuration.
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., "@tesla-powerwall What's my current battery level?"
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.
A Model Context Protocol (MCP) server that provides tools to interact with your Tesla Powerwall 2 local gateway API. This allows AI assistants like Claude to monitor and control your Powerwall system.
powerwall_login - Authenticate with your Powerwall gateway
powerwall_logout - Expire your authentication token
powerwall_get_meters_aggregates - Get real-time power metrics for solar, grid, battery, and home
powerwall_get_soe - Get battery state of energy (charge percentage)
powerwall_get_system_status - Get overall system status
powerwall_get_status - Get Powerwall version and uptime
powerwall_get_site_info - Get site configuration and capacity
powerwall_get_grid_status - Check grid connection status
powerwall_get_powerwalls - List all Powerwalls and their status
powerwall_get_meters - Get detailed meter information
powerwall_get_solars - Get solar array information
powerwall_set_operation - Change operation mode (self_consumption, backup, autonomous, scheduler)
Set backup reserve percentage
powerwall_get_operation - View current operation mode settings
powerwall_get_config - Get system configuration
powerwall_get_customer - Get customer registration info
powerwall_get_installer - Get installer information
powerwall_get_networks - Get WiFi network information
powerwall_get_device_type - Get device type details
Related MCP server: Tessie MCP Server
# Clone or create the project
npm install
# Build the TypeScript code
npm run buildSet these environment variables or create a .env file:
POWERWALL_HOST=192.168.1.xxx # Your Powerwall gateway IP or hostname
POWERWALL_USERNAME=customer # Usually "customer"
POWERWALL_PASSWORD=xxxxx # Last 5 digits of gateway serial number or custom password
POWERWALL_EMAIL= # Optional emailGateway IP Address: Check your router's connected devices or use the Tesla app
Password:
Open the Tesla app
Go to Settings → My Home Info
Find "Powerwall Gateway" serial number
Use the last 5 digits as your password (unless you set a custom password)
Add to your Claude Desktop configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%/Claude/claude_desktop_config.json
{
"mcpServers": {
"tesla-powerwall": {
"command": "node",
"args": ["/path/to/tesla-powerwall-mcp/dist/index.js"],
"env": {
"POWERWALL_HOST": "192.168.1.xxx",
"POWERWALL_USERNAME": "customer",
"POWERWALL_PASSWORD": "xxxxx"
}
}
}
}Once configured, you can ask Claude things like:
"What's my current battery level?"
"How much solar power am I generating right now?"
"Show me all my power metrics"
"What's my Powerwall operation mode?"
"Change to self-consumption mode with 20% backup reserve"
"Is the grid connected?"
"What's my home power consumption?"
"How many Powerwalls do I have?"
When you query powerwall_get_meters_aggregates, you'll see power values in watts:
site (Grid):
Positive = drawing power from grid
Negative = sending power to grid
battery (Powerwall):
Positive = discharging (powering home)
Negative = charging
solar:
Positive = generating power
load (Home):
Power being consumed by your home
self_consumption: Use solar/battery to power home, grid as backup
backup: Prioritize keeping battery charged for outages
autonomous: Time-based control (if configured)
scheduler: Custom schedule mode
⚠️ Important Security Considerations:
Self-Signed Certificate: The Powerwall uses a self-signed SSL certificate. This server accepts it by setting rejectUnauthorized: false. This is standard for local Powerwall access but means SSL verification is disabled.
Local Network Only: Only use this on your trusted local network. Never expose your Powerwall gateway to the internet.
Credentials: Keep your gateway password secure. Anyone with access can control your Powerwall.
Token Storage: Authentication tokens are stored in memory only during the session.
Based on the community-documented API at: https://github.com/vloschiavo/powerwall2
Cannot connect to Powerwall:
Verify the IP address is correct
Make sure you're on the same network as your Powerwall
Check firewall settings
Authentication fails:
Verify password is correct (last 5 digits of gateway serial)
Try using the custom password if you set one
Some firmware versions may require different authentication
"Error: self signed certificate":
This is expected. The server handles self-signed certificates automatically.
tesla-powerwall-mcp/
├── src/
│ └── index.ts # Main MCP server code
├── dist/ # Compiled JavaScript (generated)
├── package.json
├── tsconfig.json
└── README.md# Install dependencies
npm install
# Build
npm run build
# Run directly
npm startContributions welcome! This server implements the documented endpoints from the community research at https://github.com/vloschiavo/powerwall2
MIT
This is an unofficial tool and is not affiliated with Tesla, Inc. Use at your own risk. The author is not responsible for any issues that arise from using this software to interact with your Powerwall system.
API documentation: https://github.com/vloschiavo/powerwall2
MCP Protocol: Anthropic
Community research and testing by Tesla Powerwall owners
Get system configuration
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Get system configuration' with no indication of output format, error behavior, side effects, or whether it is read-only (though 'get' implies it). No additional behavioral context is provided.
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 that is front-loaded, but it is under-specified rather than truly concise. It lacks the detail needed to be useful, so it does not earn its place fully.
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 many sibling tools with specific scopes (meters, status, site info, etc.), this description is severely incomplete. It does not clarify what 'configuration' encompasses or how it differs from other getters, leaving the agent without sufficient information 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?
There are zero parameters, so the schema is trivially 100% covered. Per the rubric, 0 parameters earns a baseline of 4. The description adds no parameter-related information, but 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 states the verb 'Get' and a resource 'system configuration', but 'system configuration' is vague and doesn't specify what it includes. It does not differentiate from siblings like 'powerwall_get_system_status' or 'powerwall_get_site_info', making the purpose ambiguous.
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 does not mention any conditions, prerequisites, or exclusions, leaving the agent to guess which getter is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get customer registration information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. The word 'Get' implies a read-only operation, but the description does not mention authentication requirements, potential errors, privacy implications, or what the response contains beyond 'registration information'.
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 clear sentence with no wasted words. It is appropriately front-loaded, though it is also somewhat thin and could include a bit more 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?
For a zero-parameter getter, the description is minimally sufficient to understand the tool's purpose. However, without an output schema or any explanation of the expected response shape or usage context, an agent is left guessing at the exact return structure and whether any special conditions apply.
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 already fully covers parameter semantics. The description does not need to add anything; the no-parameter baseline of 4 is appropriate.
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 ('Get') and resource ('customer registration information'), making it clear what the tool returns. It does not explicitly distinguish it from siblings like powerwall_get_installer, but the customer-specific wording gives enough differentiation for most cases.
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?
There is no guidance about when to use this tool versus the many sibling getter tools. No context is provided about prerequisites, typical workflows, or situations where another tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get device type information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden. The verb 'Get' clearly signals a read-only operation, which is the main behavioral trait. However, it does not mention authentication, return format, or any potential side effects, so transparency is minimal but not misleading.
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 very short and front-loaded with the verb, with no wasted words. However, it adds little beyond the tool name and lacks substantive detail, making it more under-specified than genuinely helpful.
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 getter, the description is nearly sufficient: an agent can infer it should call the tool to retrieve device type information. The main gap is the absence of any output schema or explanation of what the returned device type information looks like, but the simplicity of the tool reduces the need for extensive context.
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 is empty, so there are no parameters to document. Per the rubric, a zero-parameter tool gets a baseline of 4; the description adds no parameter details, but none 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 states the verb 'Get' and a resource 'device type information,' so it is not a pure tautology. However, it is quite vague and does not explain what 'device type' means or what information is returned, leaving the agent to infer the purpose mostly from the tool name.
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?
There is no guidance on when to use this tool versus the many sibling getters, nor any mention of exclusions or alternatives. The description simply restates the operation, so an agent receives no context for choosing this tool over powerwall_get_site_info, powerwall_get_status, etc.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get grid connection status
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The verb 'Get' implies a read-only operation with no side effects, which is useful given no annotations are provided. However, the description does not disclose additional behavioral details such as authentication requirements, response shape, or whether the status is live or cached.
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. For a zero-parameter status getter, this is appropriately sized and easy to parse.
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 definition is minimally viable for a simple no-parameter getter, but it lacks usage guidance and behavioral context that would help an agent choose it confidently among many sibling status tools. Since there is no output schema, a bit more detail about what 'grid connection status' actually contains would improve completeness.
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 takes zero parameters and the input schema is empty and fully covered. There are no parameter semantics for the description to add, so the baseline for zero-parameter tools applies.
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 and resource ('Get grid connection status'), clearly identifying what the tool does. It is not vague, though it essentially restates the tool name and does not explicitly differentiate itself from siblings like powerwall_get_system_status.
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 about when to use this tool versus alternatives. With many sibling getters, an agent is not told whether to prefer this over system status or meters aggregates.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get installer information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but no side effects, authentication requirements, or return-value behavior are described.
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 filler. However, it achieves brevity by omitting useful context, so it is not a 5.
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 no annotations, the description is the only source of behavioral context. It does not say what installer information is returned or how it differs from config, customer, or site info, leaving a clear gap for a 0-parameter tool.
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 baseline is 4. There are no input semantics to explain, and the description does not need to compensate for schema gaps.
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 clear action and resource: retrieving installer information. It does not explicitly distinguish itself from sibling getters, but 'installer' is a distinct resource among the powerwall_get_* family.
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 about when to use this tool instead of alternatives like powerwall_get_customer or powerwall_get_site_info. The agent must infer usage from the resource name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed meter information for all meters
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but the description does not mention response format, granularity, authentication requirements, or potential variability across connected Powerwall systems. This is minimally transparent but leaves important behavioral context unstated.
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 filler or redundancy. It front-loads the action and resource clearly.
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 getter, the description is minimally viable: an agent knows the operation and resource. However, there is no output schema and no detail about what 'detailed meter information' contains, and the sibling tool powerwall_get_meters_aggregates is not addressed. Some ambiguity remains about whether this returns individual meter readings, totals, or both.
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 there is no parameter semantic burden. Baseline of 4 is appropriate because no parameter documentation 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 states a clear verb ('Get') and resource ('meter information'), identifying what the tool does. It does not explicitly distinguish itself from the sibling powerwall_get_meters_aggregates, though 'detailed meter information for all meters' implies a per-meter level of detail.
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 given about when to use this tool versus powerwall_get_meters_aggregates or any other sibling. There are no exclusions, contexts, or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current readings from meters measuring solar, grid, battery, and home power
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. 'Get' clearly implies a read-only operation, and the meter scope is stated. However, it does not mention response format, whether readings are point-in-time snapshots, or any access prerequisites. This is minimal but not misleading.
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. The verb and resource are prominent, and the categories add just enough specificity without bloat.
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, the description is mostly adequate. The main gap is a lack of clarification on what 'aggregates' means and how this tool differs from the nearly identical sibling powerwall_get_meters. An agent could struggle to pick the correct tool among the meter-related 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?
The tool has zero parameters, so the schema already fully describes the invocation contract. The description has no additional parameter-level meaning to provide, earning the baseline score of 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 ('Get'), a clear resource ('current readings from meters'), and enumerates what those meters measure (solar, grid, battery, home). It is unambiguous in its operation, though it does not differentiate itself from the similarly named sibling powerwall_get_meters.
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 information is provided about when to use this tool versus alternatives. Given the existence of powerwall_get_meters and other meter-related siblings, the agent is left without guidance on which tool fits the 'aggregates' nuance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get WiFi network information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full behavioral burden. The phrase 'WiFi network information' is generic and does not specify whether this returns nearby/available networks, the current connection, or network configuration, nor any prerequisites. The read-oriented verb is the only behavioral information.
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 six-word verb phrase with no filler, front-loading the operation and resource. It is appropriately concise for this simple tool, though that brevity comes at the expense of behavioral 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?
With no output schema, the description does not explain what 'WiFi network information' concretely contains, leaving an agent to guess the return shape. However, the call requires no inputs and the operation is simple, so the gap is moderate rather than severe.
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 and 100% schema description coverage, so there is nothing for the description to add. A baseline of 4 is appropriate for a parameterless call.
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 clear verb ('Get') and a specific resource ('WiFi network information'), which is distinct from sibling getters like system status or site info. It doesn't explicitly contrast with siblings, but the resource name leaves little ambiguity about what is returned.
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 when-to-use guidance or alternative routing is provided. With 17 sibling tools all following the same 'get_*' pattern, an agent must rely on naming conventions alone to choose this tool. There are no conditions, prerequisites, or exclusions stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current operation mode settings
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral disclosure burden. The verb 'Get' signals a read-only operation and 'current' implies a snapshot, but the description does not disclose authorization needs, side effects, or response behavior. Some behavioral signal is present, but it is minimal.
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, front-loaded sentence with no filler or repetition. It conveys the action and the target resource efficiently.
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 getter, this is close to sufficient, but with no output schema and no annotations the meaning of 'operation mode settings' and the response shape are left implicit. It is also missing routing guidance among the many similar getter siblings, so it is adequate but not 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 zero parameters, so there is nothing for the description to document. The word 'current' adds a slight semantic hint that this is a live snapshot requiring no arguments, aligning with the 100% schema coverage baseline.
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 the specific verb 'Get' with the resource 'current operation mode settings', clearly stating what the tool retrieves. It is also easily distinguished from the sibling 'powerwall_set_operation' and the other getter tools by naming a distinct resource.
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?
There is no guidance about when to use this tool compared to siblings like powerwall_get_status, powerwall_get_config, or powerwall_get_system_status. The description only restates the operation and provides no scenarios, prerequisites, or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get list of Powerwalls and their status
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description must carry the full burden of behavioral disclosure. It only states the action and gives no information about side effects, read-only nature, authentication, or response behavior. It is not contradictory, but it adds no behavioral context beyond the literal 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?
The description is a single efficient sentence with no wasted words. It conveys the action and target concisely, earning its place without drift.
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 covers the core function but is minimal. It could elaborate on what 'status' includes or how this differs from related get tools, but it is adequate for a basic list operation.
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 description is not required to describe any. With no parameters present, the baseline score of 4 applies, and the description does not need to compensate for parameter documentation.
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 (get) and resource (Powerwalls) with the information returned (their status). It is clear and distinct from siblings like get_system_status because it focuses on the Powerwall devices themselves, even though it does not explicitly contrast with alternatives.
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?
There is no guidance on when to use this tool versus the many other get_* siblings. No context, prerequisites, or alternative tool references are provided, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get site information including nominal system energy and power
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It simply states that it gets information, which implies a read operation, but it does not mention any side effects, permissions, rate limits, or how the response is structured. For a simple get this may be acceptable, but it adds nothing beyond the literal 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?
The description is a single, focused sentence that conveys the core purpose without unnecessary words. It is front-loaded and efficient, fitting the tool's simplicity.
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 has no parameters and no output schema, the description is the only source of context. It indicates what is included but not the full return shape or any limitations. For a simple get with no annotations, this is adequate but leaves some ambiguity about the exact response.
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 schema coverage is 100%. Per the calibration rule, a baseline of 4 is appropriate when no parameter documentation is needed. The description does not need to add parameter semantics.
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 ('Get') and the target ('site information'), with a specific indication of included data ('nominal system energy and power'). It is distinct enough from the sibling tools like get_system_status or get_config because it focuses on site-level energy/power details, but it does not explicitly name a differentiating alternative.
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?
There is no guidance on when to use this tool versus the many sibling get_* tools. The description gives no context about what scenarios favor this call over others, leaving the agent to infer based on the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get state of energy (battery charge percentage)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what is retrieved but does not mention whether authentication is required, whether any side effects exist, or how the value is returned. The 'Get' verb implies read-only, but this is not made explicit.
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, focused sentence with no filler. The lead 'Get state of energy' is immediately informative, and the parenthetical adds clarity about the unit of measurement.
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 no annotations, the description only partially covers what the agent needs to know. It clarifies the output is a percentage but does not specify format/range or any dependency on a prior login. For a parameterless read, this is close, but still leaves minor uncertainty.
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 schema is complete (100% coverage of an empty object). The description does not need to add parameter details; the baseline for a parameterless 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 uses a specific verb ('Get') and resource ('state of energy') and clarifies it as battery charge percentage, making the function's intent clear. However, it does not explicitly contrast with sibling getters such as powerwall_get_system_status, so it lacks an explicit sibling differentiation.
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 provides no guidance on when to prefer this tool over alternatives (e.g., powerwall_get_system_status, powerwall_get_meters_aggregates). It does not state prerequisites or use cases beyond the bare purpose, so an agent must infer usage entirely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get solar array information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations and no output schema, the description carries the full burden of behavioral disclosure. 'Get' weakly implies read-only, but the description does not mention what data is returned, whether authentication is required, or any caveats about the response.
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 communicates the action and resource with no wasted words. Every part of the description 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 getter, this is minimally sufficient to invoke, but 'solar array information' is vague and there is no output schema to clarify the exact return shape. The agent can call it, but the description leaves interpretation open.
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 is empty, so parameter semantics are not applicable. Per the baseline for zero-parameter tools, the description need not add parameter details, and it correctly avoids inventing any.
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 names a concrete verb and resource: 'Get solar array information.' It is easy to understand what the tool does, but it does not explicitly distinguish itself from sibling getters like powerwall_get_powerwalls or powerwall_get_system_status, so it falls short of a 5.
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 about when to use this tool versus the many sibling getters. The resource phrasing implies 'use when you need solar array info,' but there are no explicit alternatives, exclusions, or context cues for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get Powerwall status including version and uptime
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'Get' but does not explicitly state whether this is a read-only operation, whether authentication is required, whether it may fail without an active session, or what the response contains beyond version and uptime. This is a meaningful gap for a tool with no annotation safety hints.
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, front-loaded sentence with no filler. 'Get Powerwall status including version and uptime' is concise, direct, and every word contributes to the meaning.
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 parameterless tool, the description is mostly adequate, but it leaves out operational context that would help an agent: whether a login is required first, what 'status' encompasses beyond version and uptime, and how this differs from powerwall_get_system_status. Given no output schema and no annotations, slightly more detail would make it 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 tool has zero parameters, so the description is not required to explain parameter behavior. The baseline for zero-parameter tools is 4, and the description does not introduce any confusion about inputs.
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 ('Get') and identifies the resource ('Powerwall status') with concrete examples ('version and uptime'). It is reasonably distinguishable from sibling tools like powerwall_get_system_status due to the mentioned fields, though it does not explicitly contrast itself with that sibling.
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 provides no guidance on when to use this tool versus alternatives such as powerwall_get_system_status or powerwall_get_meters_aggregates. There is no elaboration on required preconditions like authentication or session state, which is especially relevant given the presence of login/logout siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get overall system status and information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description must carry the behavioral disclosure burden. It only says 'Get', which implies read-only, but provides no detail on response contents, authentication needs, or any operational caveats. This is minimal behavioral context.
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 one concise sentence and front-loads the core purpose. The trailing 'and information' is somewhat vague filler, but it does not significantly hurt conciseness.
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 no annotations, the description should explain what 'overall system status' means and what data the agent can expect in the response. It does neither, and the sibling naming collision makes the context incomplete for tool selection.
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 takes zero parameters, so there is nothing for the description to clarify. Schema coverage is effectively 100% and no parameter documentation 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 states a clear verb ('Get') and a reasonably specific resource ('overall system status and information'). However, it does not differentiate this from the closely named sibling 'powerwall_get_status', so an agent cannot tell them apart based on the description alone.
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 usage guidance is provided. The description does not mention when to prefer this tool over alternatives like powerwall_get_status, powerwall_get_site_info, or powerwall_get_operation, nor does it state any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Authenticate with the Powerwall gateway and obtain an access token
| Name | Required | Description | Default |
|---|---|---|---|
| No | Email address (optional) | ||
| password | Yes | Password (last 5 digits of Gateway serial number or custom password) | |
| username | No | Username (typically 'customer') | customer |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It states the core action and result, but does not disclose side effects (e.g., token storage for subsequent calls), failure conditions (invalid credentials), or that it is a prerequisite for other tools. This is a minimal disclosure typical of a login operation but lacks depth beyond the obvious.
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, efficient sentence that front-loads the action and outcome. There is no redundant wording, and it is appropriately concise for a straightforward login 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?
For a simple login tool with fully documented parameters and no output schema, the description covers the essential purpose. However, it omits integration context (e.g., that this token is needed for subsequent API calls) and does not explicitly mention usage prerequisites, leaving minor gaps in completeness.
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 100% coverage, with each parameter (email, password, username) having descriptive text. The description adds no parameter-level information beyond what the schema provides, so the baseline of 3 applies.
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 specific action: 'Authenticate with the Powerwall gateway' and the outcome 'obtain an access token'. It distinguishes itself from the sibling tools (e.g., getters, logout) by being the only authentication entry point, so an agent can easily identify its role.
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 its usage as the initial authentication step for accessing Powerwall data, but it does not explicitly state when to use it (e.g., 'call this before other powerwall tools') or when not to use it. No prerequisites or alternatives are mentioned, leaving the context implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Logout and expire the current authentication token
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose behavior. It clearly states that the tool 'expire[s] the current authentication token', which is the core side effect. It doesn't cover failure modes or reversibility, but for a logout action this is reasonably 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 a single, terse phrase that fully conveys the action. It contains no filler, is front-loaded with the verb, and is appropriately sized for a tool with no parameters.
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 simple logout tool with no parameters and no output schema, the description covers the essential effect. It could mention whether authentication is required or how it handles an already-expired token, but such details are arguably secondary and not critical for correct invocation.
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 takes zero parameters and the input schema is empty, so the description has no parameter semantics to add. Per the baseline for 0 params, a score of 4 is appropriate; no compensation 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 uses a specific verb 'Logout' and names the resource 'authentication token', clearly stating what the tool does. It is distinct from siblings like powerwall_login and the various get/set tools, leaving no ambiguity about its function.
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 purpose implies usage after a session is established, but there is no explicit mention of when to use it versus alternatives, nor any conditions or prerequisites. The contrast with powerwall_login is implicit but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set operation mode (self_consumption, backup, autonomous, etc.)
| Name | Required | Description | Default |
|---|---|---|---|
| mode | Yes | Operation mode: self_consumption, backup, autonomous, scheduler | |
| backup_reserve_percent | No | Backup reserve percentage (0-100) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the mutation ('Set') but does not describe side effects, whether a mode change is persistent, required authentication, or how backup_reserve_percent interacts with modes. Significant behavioral context is missing.
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 efficient sentence with the action front-loaded. The trailing 'etc.' is vague and unhelpful since the enum has only four values, but the overall length is appropriate.
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 simple setter with two parameters, the description plus schema is mostly adequate, but there is no output schema and no note about response behavior, error conditions, or the relationship between mode and backup_reserve_percent. The tool would benefit from stating that backup_reserve_percent is relevant in backup mode.
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 description coverage is 100%, so the baseline is 3. The description adds no extra parameter meaning beyond listing some enum values; it does not explain backup_reserve_percent or when it applies, but the schema already documents both parameters.
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 states a specific verb ('Set') and resource ('operation mode'), and lists representative values. It clearly differentiates from the many powerwall_get_* siblings, especially powerwall_get_operation, by indicating a write/change action.
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 intended use is implied by the verb 'Set' and the mode values, but there is no explicit guidance on when to use this tool versus alternatives, no mention that reading current mode should use powerwall_get_operation, and no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0powerwall_get_configpowerwall_get_customerpowerwall_get_device_typepowerwall_get_grid_statuspowerwall_get_installerpowerwall_get_meterspowerwall_get_meters_aggregatespowerwall_get_networkspowerwall_get_operationpowerwall_get_powerwallspowerwall_get_site_infopowerwall_get_soepowerwall_get_solarspowerwall_get_statuspowerwall_get_system_statuspowerwall_loginpowerwall_logoutpowerwall_set_operationScored across 18 tools
Most tools map to distinct resources, but several read-only getters overlap in purpose, such as get_status vs get_system_status and get_meters vs get_meters_aggregates. An agent may struggle to choose between status-related endpoints without deeper API knowledge.
All tools use a consistent powerwall_ prefix with snake_case verb_noun names. The only non-get tools are login, logout, and set_operation, which clearly follow the same predictable action-based pattern.
18 tools is on the heavier side but appropriate for a Powerwall gateway server that exposes many distinct API resources. Each tool appears to represent a real endpoint, so the count is justified rather than bloated.
The server covers authentication, status, meters, battery state, grid status, operation settings, configuration, and installer details. The main gap is limited write operations beyond setting operation mode, but for monitoring and basic control the surface is largely complete.
Control your Tesla from your AI assistant - climate, charging, access, and security.
Unofficial integration! ## ✨ Key Features ### 💰 Financial Intelligence - **Smart Charging Cost An…
Control your Tesla - wake it, warm it up, unlock and more. Get your developer token at https://Infoseek.ai/mcp. Also requires your own Tesla developer token which is tied to your car/fleet.
Solar, weatherization, EV charging, battery and heat-pump decision tools for AI agents.