Retrieves vehicle telemetry data from Salesforce Asset and Vehicle_Telemetry__c objects, enabling health scoring, DTC decoding, and maintenance predictions for connected vehicles.
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., "@connected-vehicle-health check the health of vehicle with VIN 1HGCM82633A123456"
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.
An MCP server that exposes a connected-vehicle OBD-II / telematics platform to AI agents. It maps raw OBD-II PIDs and CAN signals into a rolled-up vehicle health score and provides tools for querying live data, decoding diagnostic trouble codes (DTCs), forecasting maintenance, and issuing gated remote commands.
The data layer is pluggable (src/provider.ts). Two backends ship:
salesforce (default) — live data from a Salesforce org's standard Asset
object (the vehicle; VIN in SerialNumber) joined to the custom
Vehicle_Telemetry__c object (VIN__c == Asset.SerialNumber).
simulator — an in-memory mixed fleet (ICE, diesel, EV) with deterministic
signals and injectable faults; zero external dependencies.
Select with VEHICLE_DATA_SOURCE=salesforce|simulator. The tool/resource layer is
identical for both.
Full reference: see
DOCUMENTATION.mdfor architecture, the complete tool/resource/type schema, the Salesforce field mapping, the scoring model, and extension points.
Tool | Type | Purpose |
| read | Enumerate the fleet with profile + last-seen |
| read | Overall + per-domain health score (0–100) |
| read | Snapshot of selected live PID / CAN values |
| read | Active stored / pending / permanent codes |
| read | Reproducible time-series for one PID |
| read | Explain a code: causes, symptoms, fixes |
| compute | Ranked component failure risks |
| action | Reset codes / MIL (requires |
| action | Remote lock/climate/immobilize (requires |
URI | Content |
| Make, model, year, powertrain, odometer |
| Latest health snapshot |
| Recent trips + behavior events |
| Fleet-wide health roll-up |
| DTC knowledge base |
Related MCP server: DIMO MCP Server
Seven domains, each scored 0–100 and weighted into the overall score. EVs drop
emissions and fuel; the remaining weights are renormalized to 100%.
Domain | Weight | Driven by |
Powertrain | 25% | Misfires, timing, load |
Emissions | 15% | Lambda, catalyst temp, EGR |
Fuel | 12% | Short/long fuel trims |
Battery | 18% | 12V voltage/SoH, HV SoH, cell delta |
Thermal | 12% | Coolant, oil, HV pack temp |
Driveline | 10% | Trans temp, tire pressures |
DTC | 8% | Active code count + severity |
Overall status: good (≥80), attention (≥60), critical (<60).
Sparse sources score honestly. A domain is only scored when its signals are
present; domains with no data are omitted and the weights are renormalized over the
domains that were scored. So a Salesforce vehicle that reports only coolant temp,
battery %, tire pressure, and DTC codes is scored on thermal, battery, driveline,
and dtc — powertrain/emissions/fuel are simply not fabricated.
The salesforce backend reads the org directly with jsforce:
Canonical field | Salesforce source | Notes |
VIN |
| Drives vehicle identity |
Make / model / year | parsed from | e.g. |
Powertrain | inferred | EV if make is EV-only or |
Odometer |
| miles → km |
Coolant temp |
| °F → °C (omitted for EVs) |
Tire pressure |
| PSI → kPa (applied to all four) |
Battery |
| HV SoC for EVs; 12V proxy for ICE |
DTCs |
| comma/space-separated; decoded via the catalog |
The fleet is driven by the VINs present in Vehicle_Telemetry__c, so only vehicles
that actually report telemetry appear — unrelated Asset records are ignored.
SF_ACCESS_TOKEN + SF_INSTANCE_URL
SF_USERNAME + SF_PASSWORD (+ SF_SECURITY_TOKEN, SF_LOGIN_URL)
Salesforce CLI — sf org display --target-org $SF_TARGET_ORG (default alias
vehicleHealth). Easiest for local dev; just be logged in via sf org login web.
See .env.example. An expired CLI session is refreshed automatically on the next query.
Per-capability flags gate the two action tools:
Action | Salesforce | Behavior |
| enabled ( | Inserts a new |
| disabled ( | This org has no telematics command channel, so remote commands return a clear message and are not dispatched. |
Both actions are fully functional under the simulator backend.
Requires Node.js 18+.
cd connected-vehicle-mcp
npm install
npm run build # compile TypeScript to dist/Run directly during development (no build step):
npm run devInspect interactively with the MCP Inspector:
npm run inspectThe server speaks stdio. Add it to your client config. For Cursor
(.cursor/mcp.json or the workspace .mcp.json):
{
"mcpServers": {
"connected-vehicle-health": {
"type": "stdio",
"command": "node",
"args": ["/Users/sarfaraz.nawaz/Dev/PruJap/connected-vehicle-mcp/dist/index.js"],
"env": {
"VEHICLE_DATA_SOURCE": "salesforce",
"SF_TARGET_ORG": "vehicleHealth"
}
}
}
}For Claude Desktop, add the same block to claude_desktop_config.json. To run
disconnected from an org, set "VEHICLE_DATA_SOURCE": "simulator".
Once connected to the org, ask the agent things like:
"List the fleet and show any vehicle with health under 80." (Camry is critical)
"Why is the check-engine light on for the 2018 Toyota Camry?" (reads + decodes DTCs)
"Show the coolant temperature history for the Accord." (get_parameter_history)
"Predict upcoming maintenance for the Camry." (overheat + misfire + low tires)
"Is the Model 3's battery degrading?" (surfaces P0A80 — replace hybrid battery pack)
This simulator is for development. Before pointing it at real vehicles:
Gate all actions. clear_dtcs and send_command require confirm=true and are
annotated destructiveHint. Drive-affecting commands (immobilize/mobilize) should
additionally require a second human approval and are always logged.
Scope auth per VIN with short-lived tokens; never grant fleet-wide actuation by default.
Rate-limit and audit every action; the simulator keeps an in-memory command log as a stand-in.
Treat VIN, GPS, and driver identity as PII. Do not log to stdout (reserved for the MCP stream).
src/
index.ts MCP server: tool + resource registration, stdio transport
provider.ts DataProvider interface + factory (salesforce | simulator)
salesforceProvider.ts Live org backend: Asset + Vehicle_Telemetry__c via jsforce
simulatorProvider.ts In-memory simulator backend
fleet.ts Deterministic signal simulator + fault injection
health.ts Domain scoring + predictive-maintenance rules
pids.ts OBD-II PID catalog (PID → unit → reader)
dtcCatalog.ts DTC knowledge base + classifier for decode_dtc
audit.ts In-memory action/command audit log
types.ts Shared domain typesClear stored and pending DTCs and reset the MIL. Requires confirm=true. Disabled for read-only backends (e.g. Salesforce).
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | Vehicle VIN | |
| confirm | No | Must be true to execute this write action. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare destructiveHint=true and openWorldHint=true. The description adds specificity: it resets the MIL, requires confirm=true, and is disabled for read-only backends. No contradiction with annotations.
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 critical usage conditions. No wasted words.
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 action tool with established annotations and no output schema, the description covers the core behavior, conditions, and limitations. It lacks details on return value (e.g., success indication) but is sufficiently 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?
Schema coverage is 100%, so the schema fully documents both parameters. The description only reiterates the confirm requirement, adding minimal extra meaning. Baseline 3 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 and resource: 'Clear stored and pending DTCs and reset the MIL.' This clearly distinguishes it from sibling tools like get_dtcs (retrieval) and decode_dtc (decoding).
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 specifies when to use ('clear DTCs'), a prerequisite ('confirm=true'), and when not to use ('disabled for read-only backends'). It does not explicitly compare to siblings but provides sufficient context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Explain a diagnostic trouble code: system, likely causes, symptoms, and recommended actions.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | DTC code, e.g. 'P0420' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only says 'explain' without indicating that it is read-only, whether it requires network access, or how it handles invalid codes. More transparency is needed.
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, well-structured sentence that conveys the essential information without any extraneous words. It is front-loaded and efficient.
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 tool with one parameter and no output schema, the description adequately explains the output structure (system, causes, symptoms, actions). It lacks details on edge cases or prerequisites but is reasonably complete given the low complexity.
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 100% with a single parameter 'code' described as 'DTC code, e.g. 'P0420''. The tool description does not add additional semantic value beyond that, so a baseline score of 3 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 clearly states the verb 'explain' and the resource 'diagnostic trouble code', and specifies the content of the explanation (system, causes, symptoms, actions). This distinguishes it from sibling tools like 'clear_dtcs' and 'get_dtcs'.
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 does not provide any guidance on when to use this tool versus its siblings. It lacks explicit context on prerequisites, when-not-to-use, or alternatives, 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.
Return active DTCs for a vehicle, with severity and affected domain.
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | Vehicle VIN |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, and the description only states what is returned without disclosing behavioral traits such as authentication needs, error handling, or rate limits.
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, though it could front-load key information more explicitly.
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?
Without an output schema, the description lacks details on the return format, making it incomplete for an agent to fully understand the tool's output.
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 100% for the single parameter, and the description adds no extra meaning beyond the schema's 'Vehicle VIN' description.
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 returns active DTCs with severity and affected domain, distinguishing it from sibling tools like clear_dtcs and decode_dtc.
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 like get_vehicle_health or decode_dtc.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the recent time-series for one PID (most recent limit readings, oldest → newest). Useful for trend charts and degradation analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| pid | Yes | PID key, e.g. 'coolant_temp' or 'battery_12v_soh' | |
| vin | Yes | Vehicle VIN | |
| limit | No | Max number of readings |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses ordering (oldest to newest), limiting (most recent `limit` readings), and that it returns a time-series. However, it does not describe error cases, return format, or side effects. The provided info is adequate but not exhaustive.
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 with no wasted words. The purpose is front-loaded, followed by a practical use case. Excellent 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?
Given the simplicity of the tool (3 parameters, no output schema, no nested objects), the description covers purpose, parameter intent, and use case. It could mention the return format (e.g., array of {timestamp, value}) to be fully complete, but overall it is sufficient for an agent to understand when and how to use it.
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 100% with each parameter described. The description adds minimal value beyond schema, only reinforcing the role of 'limit' as 'most recent readings'. Baseline 3 is appropriate as it does not significantly enhance parameter understanding.
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 returns 'recent time-series for one PID' with ordering and limit, and gives a concrete use case ('trend charts and degradation analysis'). It effectively distinguishes from siblings like 'read_live_pids' which serves a different purpose (live data).
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 usage for historical trend analysis but does not explicitly state when NOT to use it (e.g., for real-time data, use read_live_pids). The context is clear but lacks explicit exclusions or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the overall health score (0–100) and per-domain breakdown for a vehicle. Only domains with supporting data are scored. Optionally filter to specific domains.
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | VIN (stored as Asset.SerialNumber in Salesforce) | |
| domains | No | Optional subset of domains to include |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses that only domains with supporting data are scored, but lacks information on error handling (e.g., invalid VIN), permissions, or rate limits. The description is adequate but could be more thorough.
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, 18 words, front-loaded with key output, and no filler. Every word earns its place and the structure is efficient.
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 two-parameter read-only tool with no output schema, the description sufficiently explains the output (score and breakdown) and filtering. It misses mention of error responses but is otherwise complete for practical use.
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 100%, providing a baseline of 3. The description adds value by clarifying that only domains with supporting data are scored and that filtering is optional, giving context beyond the schema's property descriptions.
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 specifies the tool's output: overall health score and per-domain breakdown, with scope boundaries (only domains with supporting data) and optional filtering, distinguishing it from sibling tools like get_dtcs or predict_maintenance.
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 usage for retrieving health scores but does not explicitly state when to use this tool over alternatives, nor provides conditions for when not to use it (e.g., for detailed DTCs use get_dtcs).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Enumerate all vehicles reporting telemetry, with profile and last-seen time.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description bears full responsibility for behavioral disclosure. It correctly notes the tool is enumerative and lists returned fields, but omits potential details like whether the list is complete, paginated, or requires authentication, which would be helpful for safe invocation.
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 that conveys the essential purpose without any redundant or extraneous information. Every word contributes 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?
Given the tool's simplicity (no parameters, no output schema), the description adequately covers its functionality. However, it could mention potential limitations like active vehicle filtering or result limits to ensure complete context for an AI agent.
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 no parameters, and the schema coverage is 100% (empty). Per the guidelines, zero parameters yields a baseline of 4. The description appropriately adds no additional parameter information as 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 enumerates all vehicles reporting telemetry, specifying the attributes (profile and last-seen time). It effectively distinguishes itself from sibling tools which focus on DTCs, parameters, health, and other vehicle-specific operations.
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 usage for listing vehicles but does not explicitly state when to use this tool versus alternatives like get_vehicle_health or decode_dtc. While the context of sibling tools makes the use case evident, explicit guidance is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Forecast component-level maintenance risks from current signals, DTCs, and domain scores. Returns ranked risks with recommendations.
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | Vehicle VIN |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explains that the tool forecasts risks and returns ranked recommendations, but does not disclose behavioral traits such as whether it is read-only (likely, but not stated), computational cost, or data prerequisites beyond the VIN. Without annotations, the description carries full burden and provides only basic 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 extremely concise at two sentences, front-loading the key action ('Forecast component-level maintenance risks'), and every word adds value. No redundancy or filler.
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 single parameter, no annotations, and no output schema, the description provides a clear purpose and output expectation. However, it lacks details about the output structure (e.g., what fields are in the ranked risks) and any limitations. Still, it is sufficient for an agent to understand core functionality.
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% (the 'vin' parameter is described as 'Vehicle VIN'). The tool description adds contextual information about inputs (signals, DTCs, domain scores) but does not add meaning beyond the schema for the parameter itself. Baseline of 3 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 uses the specific verb 'Forecast' and clearly identifies the resource as 'component-level maintenance risks'. It also specifies the inputs (current signals, DTCs, domain scores) and output (ranked risks with recommendations), distinguishing it from sibling tools like get_dtcs or get_vehicle_health which provide current data rather than predictions.
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 it should be used for predicting future maintenance risks based on current data, but does not explicitly state when to use this tool versus alternatives (e.g., get_vehicle_health for current state, get_dtcs for diagnostic codes). No exclusion criteria or usage context is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Snapshot of the latest OBD-II PID / CAN signal values for a vehicle. Provide PID keys, or omit for a default set. availableKeys lists what this vehicle actually reports.
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | Vehicle VIN | |
| pids | No | PID keys, e.g. ['coolant_temp','battery_12v_soh'] |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It mentions 'snapshot' implying a point-in-time read, but lacks details on idempotency, auth requirements, or side effects. It is adequate but not thorough.
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 brief sentences with no wasted words; efficiently communicates the core functionality and key usage notes.
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?
Lacks output schema and does not describe the return format or structure, though the description mentions availableKeys hinting at output content. Adequate but could be more 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?
Schema coverage is 100%, but the description adds value by noting that omitting pids gives a default set and providing an example format, which aids agent understanding beyond the schema.
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 reads live OBD-II PID/CAN signal values and mentions optional PID keys, distinguishing it from sibling tools like get_dtcs or get_parameter_history.
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 indicates when to omit PID keys for a default set and references availableKeys, but does not explicitly contrast with siblings or state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send a remote command to the vehicle (lock, climate, locate, etc.). Requires confirm=true. Disabled for read-only backends (e.g. Salesforce).
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | Vehicle VIN | |
| command | Yes | ||
| confirm | No | Must be true to execute. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, signaling mutation. The description adds important behavioral context: the need for confirmation and that the tool is disabled in read-only backends. This goes beyond the annotations by clarifying operational constraints.
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 extremely concise: two sentences that front-load the purpose and then add critical usage constraints. Every sentence adds value without redundancy.
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 absence of an output schema and moderate parameter coverage, the description effectively covers the tool's core function and key constraints. It is sufficient for an agent to understand when and how to invoke this tool, especially in context with the 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 schema covers 67% of parameters with descriptions. The description adds value by summarizing the command types and explicitly stating that confirm must be true, which reinforces the schema's default false. It does not explain the 'locate' command beyond listing it, but the enum is self-explanatory.
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: sending remote commands to a vehicle, with examples (lock, climate, locate). It distinguishes from sibling tools that are focused on diagnostics (DTCs, health, etc.), making it easy for an agent to select this tool for action-oriented tasks.
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 includes explicit usage guidance: 'Requires confirm=true' and 'Disabled for read-only backends (e.g. Salesforce).' This helps the agent know when to use the tool and when it is unavailable. It does not explicitly mention alternatives, but the sibling tools provide a natural contrast.
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.
v0.2.0clear_dtcsdecode_dtcget_dtcsget_parameter_historyget_vehicle_healthlist_vehiclespredict_maintenanceread_live_pidssend_commandScored across 9 tools
Each tool has a distinct purpose: vehicle listing, health scoring, DTC management (decode, get, clear), parameter history, live PIDs, maintenance prediction, and remote commands. No overlap.
All tool names follow a consistent verb_noun pattern in snake_case, e.g., list_vehicles, get_dtcs, send_command. No mixing of conventions.
Nine tools is well-scoped for a vehicle health domain covering diagnostics, health monitoring, historical data, live data, predictions, and commands. Not over- or under-tooled.
The tool surface covers the full lifecycle: vehicle discovery, health assessment, DTC handling (get, decode, clear), parameter history, live readings, predictive maintenance, and remote commands. No obvious gaps for the stated purpose.
Query your team's drift, vulnerability, and upgrade data from any AI assistant. OAuth 2.1, 51 tools.
Verified, pay-per-use API tools for AI agents through one authenticated connection.
Connect AI agents to financial institution origination, analytics, and compliance workflows.
Give your AI hands. Identity, credential vault, and API gateway for autonomous agents.
