evaconnect-mcp
This server is a read-only MCP interface to your Evolute vehicle account, exposing telemetry and trip data without sending commands.
evolute_status — Get current vehicle telemetry: charge, climate, doors, and online status; coordinates hidden unless
include_piiis enabled.evolute_vehicles — List vehicles on the account; VIN/IMEI masked unless
include_piiis true.evolute_trips — Retrieve recent trips for a vehicle, with optional limit, offset, sorting, and PII inclusion; addresses and track are omitted.
evolute_trip — Fetch a single trip by travel ID and start time; include track points with
include_trackand addresses withinclude_pii.evolute_charge — Show the current charge session, or an empty result if not charging.
evolute_auth_status — Check whether the stored session looks valid, without exposing raw tokens.
It intentionally does not provide OTP login, command sending, or vehicle control.
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., "@evaconnect-mcpwhat's my car's current charge and doors status?"
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.
evaconnect
Typed Python client and stdio MCP server for the Evolute companion API
(https://app.evassist.ru). Own account / own vehicle only.
Read telemetry (charge, climate, doors, online) and recent trips without the official Android app. Vehicle commands are not implemented — the command channel is unconfirmed.
Install
Python 3.12+.
cd evaconnect
python3.12 -m venv .venv
source .venv/bin/activate
pip install ".[dev]"Do not use pip install -e on Python 3.14 / macOS. Hatchling marks the
.pth as Finder-hidden; 3.14 then skips it. import evaconnect hits a
namespace leftover in site-packages/evaconnect (often only schema.sql),
and the CLI dies:
ModuleNotFoundError: No module named 'evaconnect'
ModuleNotFoundError: No module named 'evaconnect.cli'Install a regular wheel (pip install . or pip install ".[dev]"). If you
already used -e, either reinstall without it, or:
chflags nohidden .venv/lib/python*/site-packages/*.pthThen evolute --help should print the subcommands. Repeating pip install -e
puts the hidden flag back.
Entry points after install:
evolute— small CLI (status,trips,vehicles,info)evaconnect-mcp— stdio MCP serverevaconnect-poller— write telemetry/trips to Postgres for Grafana
Remote poller + Postgres next to an existing Grafana: see deploy/README.md
(RU).
Grafana dashboard JSON: deploy/grafana/dashboards/evolute.json
(folder Evolute, uid evaconnect-evolute, timezone Europe/Moscow).
Unofficial reverse-engineered HTTP spec (CC0, not vendor docs): api/README.md (RU).
Related MCP server: Rivian MCP
Auth
There is no password. The official app logs in with an SMS code. evaconnect
does the same: one SMS, then a token pair. The CLI has no login
command (and MCP never requests OTP). Use a short Python snippet.
1. Get tokens
phone / phoneCountry are whatever the official app sends. The vendor does
not document the mask; a live login used an 11-digit number (country code +
national number, no +) and a two-letter phoneCountry.
from evaconnect import EvoluteClient
phone = "00000000000"
phone_country = "XX"
with EvoluteClient() as client:
client.get_info() # optional; field is capcha, not captcha
client.request_otp(phone, phone_country) # sends one SMSWhen the SMS arrives:
from evaconnect import EvoluteClient
with EvoluteClient() as client:
client.sign_in("00000000000", "000000") # phone, SMS codeThat writes ~/.config/evolute/credentials.json (chmod 600):
{
"accessToken": "<YOUR_TOKEN>",
"refreshToken": "<YOUR_REFRESH_TOKEN>",
"userId": "",
"userToken": "",
"widgetId": "",
"carId": null
}Override the path with EVOLUTE_CREDENTIALS. carId is optional: if empty,
the client uses the first vehicle on the account. Set it after
evolute vehicles if you have more than one car.
Do not commit this file, the phone number, VIN, IMEI, or coordinates.
2. Use the tokens
Later calls send header access-token: <accessToken>, not
Authorization: Bearer. The client loads the file automatically. Env vars
EVOLUTE_ACCESS_TOKEN / EVOLUTE_REFRESH_TOKEN / EVOLUTE_CAR_ID fill
empty fields only — they do not override tokens already in the file.
evolute vehicles
evolute status
evolute trips -n 5from evaconnect import EvoluteClient
with EvoluteClient() as client:
client.refresh() # optional; also happens automatically on HTTP 401
print(client.list_vehicles())
print(client.get_telemetry(car_id=client.default_car_id()))curl (same headers the Android client sends):
TOKEN=$(python3 -c "import json,pathlib; p=pathlib.Path.home()/'.config/evolute/credentials.json'; print(json.loads(p.read_text())['accessToken'])")
curl -sS 'https://app.evassist.ru/id-service/user' \
-H "access-token: $TOKEN" \
-H 'accept: application/json' \
-H 'x-device: android' \
-H 'x-app: mobile' \
-H 'x-app-version: 5.1.22 (740)'Poller / Grafana: copy that credentials.json onto the server after the
last local use (refresh rotates refreshToken). See
deploy/README.md (RU).
MCP: point EVOLUTE_CREDENTIALS at the file, or leave tokens out of
mcp.json so the default path is used. Do not put live tokens in git.
When a data request returns 401, the client refreshes once, writes the
new pair back to the file, and retries. If refresh itself returns 401,
the pair is dead — run sign_in again. HTTP details:
api/docs/authentication.md
(RU).
Library
from evaconnect import EvoluteClient
with EvoluteClient() as client:
client.refresh()
me = client.me()
cars = client.list_vehicles() # id, plate, model; VIN/IMEI not in repr
car = client.get_vehicle(cars[0].id)
tel = client.get_telemetry(car_id=car.id) # or imei=…
session = client.get_charge_session() # may be None
trips = client.list_trips(car.id, limit=5, offset=0)
trip = client.get_trip(car.id, trips.rows[0].id, trips.rows[0].segment_start_time)get_telemetry accepts an IMEI or a mongo car _id (24 hex chars) and
resolves IMEI when needed. Those two IDs are not interchangeable.
send_command exists only as a stub and always raises NotImplementedError.
CLI
evolute info # GET /id-service/info (no token)
evolute status
evolute trips -n 5
evolute vehiclesMCP (Cursor)
stdio server. Tools (read-only):
Tool | What it returns |
| Charge, climate, doors, online. Geo hidden unless |
| List; VIN/IMEI masked unless |
| Last N trips; no addresses/track |
| One trip; track only if |
| Current charge session (or empty) |
| Session present/valid; no raw tokens |
There is no request_otp and no command-sending tool.
Cursor mcp.json example (~/.cursor/mcp.json or project .cursor/mcp.json):
{
"mcpServers": {
"evaconnect": {
"command": "/Users/nmel/Documents/Projects/evaconnect/.venv/bin/evaconnect-mcp",
"env": {
"EVOLUTE_ACCESS_TOKEN": "",
"EVOLUTE_REFRESH_TOKEN": "",
"EVOLUTE_CAR_ID": ""
}
}
}
}If the venv is on PATH, "command": "evaconnect-mcp" is enough.
Default MCP output redacts VIN, IMEI, phone, tokens, and exact coordinates
(include_pii off). Do not poll telemetry faster than once per 5 seconds
(the client caches within that window).
Tests
Mocks only — tests never call production. GitHub Actions runs pytest and
Spectral on api/openapi.yaml.
pytestGrafana dashboard
Provisioned JSON: deploy/grafana/dashboards/evolute.json.
Datasource uid evaconnect-pg. Rows:
Row | Content |
Обзор | Original nine panels: Battery, Remaining range, Temperatures (cabin/outside/battery), 12V, Online, Central lock, Odometer, Poller heartbeat, Recent trips |
Сейчас | Ignition, park, charge gun, signal, climate target/fan, last snapshot, command catalog |
Зарядка | Charge-gun timeseries |
Климат | Coolant, climate target, fan |
Кузов | Doors, trunk, headlights from |
Движение | Odometer timeseries, ignition/park/signal |
Служебные сенсоры | Fuel % / firmware / settings (often unused on EV) |
Поездки | Extra table ( |
Poller | Cycle duration and errors |
Trip addresses and coordinates are not stored. See deploy/README.md (RU).
Spec gaps (explicit parameters, no guessing)
Phone /
phoneCountryformat is unknown — pass them as strings.Trip
sort.by/dirdefault to live-confirmedDATE/DESC(DURATION/DISTANCEandASCare also valid).distanceunits (m vs km) are unknown — rawint, no conversion.Access-token TTL is unknown — one auto-refresh on HTTP 401, no loop.
Charge-session body when charging is not fully specified. See api/docs/quirks.md (RU).
Time-Zoneheader is unused (not confirmed).
Full endpoint table and x-status markers: api/README.md
(RU).
License
MIT for the Python client, MCP server, and poller.
Available Tools
6 toolsevolute_auth_statusA
Whether a session looks valid. Never returns raw tokens.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It usefully states that the tool never returns raw tokens and hedges with 'looks valid,' suggesting a heuristic check. But it does not disclose whether the call is read-only, whether it refreshes the session, or whether any side effects occur.
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 short sentences with no filler. The core purpose is stated first, and the security-relevant constraint 'Never returns raw tokens' is a valuable second sentence. Every word 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 status check with an output schema present, the description is mostly sufficient. It states what is checked and adds an important security constraint. It lacks explicit guidance on prerequisites, such as whether a session must already exist, but this is a minor gap given the tool's simplicity.
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 description coverage is 100%, so the baseline is 4. The description adds no parameter information, but none is needed because there is nothing to document.
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 identifies the resource (a session) and the condition (whether it looks valid), and the auth_status name distinguishes it from the vehicle/trip/charge siblings. However, it lacks a direct imperative verb like 'Checks' or 'Validates,' so the phrasing is a noun clause rather than a precise action statement.
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 this tool is used to determine if a session is valid, and the warning 'Never returns raw tokens' hints that it should not be used for token retrieval. However, it never explicitly states when to use it versus the sibling tools or excludes alternatives, leaving the usage context to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evolute_chargeA
Current charge session, if any. Empty when not charging.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the full behavioral burden. It usefully discloses that the result is empty when not charging, preventing misinterpretation of a no-active-session state. It does not mention auth, rate limits, or read-only semantics, but for a zero-parameter current-state getter this is sufficient.
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 two short sentences with no filler. The main resource is front-loaded, and the important conditional behavior ('Empty when not charging') is stated separately and 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 tool with an output schema available, the description covers the key edge case and return semantics. It is slightly terse about what 'current' refers to and does not cross-reference sibling tools, but nothing essential is missing for a simple read 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 and the input schema is an empty object, so there is nothing for the description to add. The baseline for a parameterless tool is appropriate here.
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 identifies the resource ('current charge session') and the conditional empty state, which distinguishes it from siblings like evolute_vehicles or evolute_trips. It lacks an explicit verb such as 'retrieve' or 'list,' but the intent is unambiguous for a simple getter.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when the tool is relevant: use it to inspect the current charge session, knowing it will be empty when not charging. However, it does not explicitly contrast it with sibling tools such as evolute_status or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evolute_statusB
Telemetry of the default (or given) vehicle: charge, climate, doors, online. Coordinates are hidden unless include_pii is true.
| Name | Required | Description | Default |
|---|---|---|---|
| car_id | No | ||
| include_pii | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It usefully reveals that coordinates are hidden unless include_pii is true, which is important privacy behavior not apparent from the schema. It does not disclose authentication needs, side effects, or read-only guarantees, but 'telemetry' implies a read operation and the PII note adds meaningful 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 concise: two sentences, no filler, and the core resource and telemetry domains are front-loaded. The PII behavior is placed second, which is appropriate. It could have used an active verb for slightly better readability, but it is otherwise well structured.
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?
Because an output schema exists, return-value details do not need to be repeated. The description covers the main domain, default/given vehicle behavior, and the key PII nuance. It still lacks explicit usage boundaries and fuller car_id semantics, so it is adequate but not complete for an agent that has no other 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?
Schema description coverage is 0%, so the description must compensate. It explicitly explains include_pii by tying it to coordinate visibility, and 'default (or given) vehicle' indirectly hints at car_id. However, car_id is never named nor its selection semantics fully described, leaving a required-for-advanced-use parameter underspecified.
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 resource (vehicle telemetry) and enumerates the covered domains: charge, climate, doors, online. It also clarifies the default-vs-given vehicle behavior and the PII gating, which helps distinguish this from simpler siblings. However, it lacks an explicit verb such as 'retrieves' and does not explicitly contrast with evolute_charge, so it is clear but not fully differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool ('default or given vehicle') but gives no explicit guidance about when to choose evolute_status over siblings like evolute_charge or evolute_vehicles. There are no when-to-use rules, exclusions, or alternative routing. An agent must infer the intended scope from the listed telemetry categories.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evolute_tripC
One trip. Track points only if include_track=true. Addresses only if include_pii=true. start_time is segmentStartTime.
| Name | Required | Description | Default |
|---|---|---|---|
| car_id | No | ||
| travel_id | Yes | ||
| start_time | Yes | ||
| include_pii | No | ||
| include_track | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It adds useful context: track points are gated by include_track, addresses by include_pii, and start_time maps to segmentStartTime. However, it does not disclose whether the operation is read-only, what happens when optional flags are false, or any other behavioral 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 very short and every clause adds some information; there is no filler. The telegraphic style somewhat reduces readability, but the content is front-loaded with "One trip" and then compactly lists the key conditional behaviors.
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?
An output schema exists, so return-format documentation is not the main gap. Still, the description omits a clear primary action, fails to explain required travel_id, and gives no guidance on how this tool relates to evolute_trips. An agent would struggle to invoke this correctly without additional 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?
Schema description coverage is 0%, so the description must compensate. It clarifies the meaning of three parameters (include_track, include_pii, and start_time mapping to segmentStartTime), but two parameters remain unexplained, including the required travel_id. This is partial compensation, not complete.
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 begins with "One trip," which largely restates the tool name rather than stating a clear action such as retrieve or list. It hints at scoping (single trip) and conditional fields, but it never says what the tool actually does with the trip. The implied distinction from evolute_trips is not made explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides parameter-level conditions ("Track points only if include_track=true", "Addresses only if include_pii=true") but no guidance on when to choose evolute_trip over siblings like evolute_trips or evolute_status. There is no explicit tool-selection guidance, and no mention of prerequisites such as where travel_id comes from.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evolute_tripsB
Recent trips for the default (or given) vehicle. Addresses and track are omitted. Distance is a raw integer (units unknown).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| car_id | No | ||
| offset | No | ||
| sort_by | No | ||
| sort_dir | No | ||
| include_pii | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It does meaningfully disclose that addresses and tracks are omitted and that distance is a raw integer with unknown units, which are valuable caveats not visible in the schema. It does not mention auth or rate limits, but for a read-like trip listing this is a strong level of 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 three concise sentences with no fluff. It front-loads the core purpose and then states two important caveats, each earning 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?
The description covers the main purpose and key output caveats, and the presence of an output schema reduces the need to describe return values. However, it does not clarify expected values for sort_by, the effect of include_pii, or pagination behavior, leaving an agent to guess for important invocation choices.
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 0%, so the description must compensate for parameter documentation. It only clarifies car_id through 'default (or given) vehicle' and says nothing about limit, offset, sort_by, sort_dir, or include_pii semantics. This is insufficient given the complete lack of schema-level 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 identifies trips as the resource and distinguishes this from the singular evolute_trip sibling by focusing on 'Recent trips' and vehicle selection. It lacks an explicit verb like 'list' or 'retrieve,' but the intent is still readily inferable.
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 explicit guidance is given about when to use this tool versus alternatives like evolute_trip or evolute_vehicles. The plural 'trips' hints at a listing operation, but there is no stated condition, prerequisite, or exclusion to help the agent choose correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evolute_vehiclesA
List vehicles. VIN/IMEI are masked unless include_pii is true.
| Name | Required | Description | Default |
|---|---|---|---|
| include_pii | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral disclosure burden. It discloses that VIN/IMEI are masked unless include_pii is true, which is valuable. However, it does not mention pagination, auth requirements, or any other operational behavior, leaving some gaps.
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 filler. The primary action is front-loaded, and the masking caveat follows naturally. Every word 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 simple list tool with one optional boolean and an existing output schema, the description covers the essentials: what the tool does and the key parameter behavior. It lacks explicit scope or pagination details, but these are less critical given the output schema and simple nature of the 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?
Schema coverage is 0%, so the description must compensate. The masking note directly explains the effect of include_pii: setting it to true reveals VIN/IMEI. This adds essential meaning beyond the bare boolean schema, though it could have explicitly stated 'set include_pii=true'.
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 and resource: 'List vehicles.' It also adds a relevant behavior about masking VIN/IMEI. It does not explicitly differentiate it from sibling tools, but the sibling names clearly suggest different resources, so the purpose is not 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?
There is no guidance on when to use this tool versus alternatives such as evolute_status or evolute_trips. The phrase 'List vehicles' implies its use, but the description provides no explicit context, exclusions, or conditions for choosing it over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
evolute_auth_status - First observed
evolute_charge - First observed
evolute_status - First observed
evolute_trip - First observed
evolute_trips - First observed
evolute_vehicles
TDQS
Scored across 6 tools
Most tools are clearly distinct: vehicles, trips, trip, auth_status, and charge each target a separate resource. The only mild overlap is evolute_status including charge information while evolute_charge focuses on the active charging session, but the descriptions clarify the boundary.
All tools follow the same evolute_ noun pattern with snake_case. Singular/plural is used intuitively (trips vs trip), and the naming is predictable across the entire set.
Six tools is a well-scoped count for an EV telemetry and connectivity server. Each tool covers a meaningful read-only operation without unnecessary bloat.
The tool set covers the core read-only domain: vehicle listing, current status, recent trips, trip details, active charge session, and auth validation. Minor gaps exist such as no direct vehicle detail endpoint or historical charge sessions, but the main workflows are supported.
Maintenance
Related MCP Connectors
Read-only access to a Zoopit account: orders, routes, fleet and live vehicle positions.
Operate a network of EV charge points over OCPP: status, sessions, tariffs, prices, remote commands
MCP server wrapping the Tesla Fleet API and TeslaMate API
Read Physical AI datasets, projects, fleet and quality data. Requires authorized Avala access.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides access to Alpha ESS solar inverter and battery system data, enabling monitoring of energy statistics, real-time power data, and configuration of battery charging and discharge schedules through the Alpha ESS Open API.10MIT
- AlicenseAqualityBmaintenanceEnables read-only access to vehicle data via the unofficial Rivian GraphQL API, allowing users to monitor battery levels, OTA updates, and charging status. It provides tools to check vehicle state and user account information directly through Claude.98 npm2MIT

Cariot MCP Serverofficial
AlicenseBqualityCmaintenanceEnables querying Cariot APIs for fleet management data, including alcohol checks, daily reports, drivers, vehicles, and realtime snapshots, with utility for generating chart configurations.728 npm1MIT- AlicenseNot gradedqualityBmaintenanceA secure, read-only MCP server that connects to BYD electric vehicles via the BYD cloud API, enabling AI agents to query real-time vehicle data such as battery SOC, range, tire pressures, door states, and GPS.MIT