Inspect the current project
Read project identity, binary size, Original/current bytes, and definitions. Paginate through maps and inspect their properties by ID.
Free & open source MIT licensed
WinOLS MCP gives compatible AI clients structured tools to inspect projects and bytes, validate proposed maps, and create map definitions in WinOLS. Built in Rust, with a local Lua bridge and a mock backend you can try today.
7 MCP tools Local stdio transport Initial implementation
Built for map-definition work
The Model Context Protocol (MCP) lets a client discover tools and call them with defined inputs. This server exposes a focused set of WinOLS operations, so a client can work with project identities, map layouts, axes, and scaling.
Read project identity, binary size, Original/current bytes, and definitions. Paginate through maps and inspect their properties by ID.
Check dimensions, byte ranges, integer storage, scaling, and optional axes against the current project. Creation checks the expected project identity and reads the resulting metadata back.
Use the in-memory mock backend on Windows or Linux to explore the same tools with synthetic data. Mock definitions reset when the server exits.
The MCP server and Lua bridge are free to use, modify, and distribute under the MIT license. Live use requires your own Windows installation, licensed WinOLS 5.93 or later in the WinOLS 5 series, and the separately purchased OLS530 Lua plugin. EVC software and licenses are not included.
The live adapter is experimental. Two 2D map definitions were created and read back on WinOLS 5.93.01 with OLS530 3.006, including axes, map-list reads, and Original/current byte checks. Full live acceptance, including persistence, supported-layout coverage, and native rollback, remains incomplete. No WinOLS version is currently certified. See the verification scope.
Tool reference
Tool schemas are exposed through MCP. The server returns structured results, including errors the client can handle.
winols_statusCheck the selected backend and whether the WinOLS bridge responds.
Input: no parameters.
winols_get_projectRead the active project's ID, name, binary size, and map count.
Input: no parameters.
winols_read_bytesRead 1–4096 Original and current bytes from a range within the project. Results include observed window and version context.
Input: expected_project_id,
address, and count.
winols_list_mapsList existing definitions with pagination.
Input: offset (default 0) and
limit (1–100; default 50).
winols_get_mapRead one definition using an ID returned by listing or creation.
Input: id.
winols_validate_mapCheck layout, axes, scaling, and bounds without creating a map. Validation does not identify map meaning or check duplicates.
Input: definition.
winols_create_mapCreate a definition and verify its properties by reading them back. Reject duplicate names or map start addresses.
Input: expected_project_id and
definition.
Quickstart
Install Rust through rustup; the repository pins its toolchain. Windows builds also require the MSVC C++ build tools and Windows SDK.
git clone https://github.com/amirdauti/redline-autohaus-winols-mcp.git
cd redline-autohaus-winols-mcp
cargo build --release --locked
.\target\release\winols-mcp.exe --backend mock --doctor
--doctor prints diagnostic JSON and exits. On Linux, use
./target/release/winols-mcp. Source installation is
available independently of downloadable release bundles.
Use an absolute executable path and the arguments below. Add these launch settings using your client's configuration format.
{
"command": "C:\\path\\to\\winols-mcp.exe",
"args": ["--backend", "mock"]
}
Without --doctor, the executable serves MCP over standard
input and output. Diagnostic messages go to standard error. The
repository also includes
client configuration and synthetic examples.
Check winols_status, read the current project, and list
its maps. Read examples/synthetic-map.json from the
repository and validate it. If valid, create the definition using
the current project ID, then read back the returned map ID.
Your client needs access to the example file, or you can paste its contents into your request. The example describes synthetic data and has no vehicle-specific meaning.
Pass the current project ID to winols_read_bytes, with a
zero-based byte address and count from 1 to
4096. The result contains equally sized original_bytes
and current_bytes arrays, plus project_id,
address, window_id, and version_name.
Window and version checks describe the observed context; they do not
provide a unique version identity or a revision lock.
Connect a licensed installation
The client launches the Rust MCP server. The server exchanges local files with the supplied Lua script running in WinOLS. This product runs on your machine; it is not an HTTP endpoint on this API host.
MCP client -- stdio --> Rust MCP server
|
local mailbox files
|
Lua bridge in WinOLS
bridge folder to a stable location.
Create a private local mailbox directory writable by your Windows
user. Use one server and one bridge per mailbox.
SCRIPT_DIRECTORY, BRIDGE_DIRECTORY,
CSV_ADDRESS_COLUMN, and CSV_DELIMITER in
winols_bridge.lua using your paths and the exact
exported address column header. The adapter accepts strict decimal
offsets and explicitly $-prefixed hexadecimal offsets.
winols_bridge.lua onto the target project window.
Run the connection check below using the same mailbox path.
--backend winols --bridge-dir C:\winols-mcp-mailbox.
Compare the project identity and complete map inventory with WinOLS
before creating a definition.
& "C:\path\to\winols-mcp.exe" --backend winols --bridge-dir "C:\winols-mcp-mailbox" --doctor
Follow the complete bridge setup and live acceptance procedure for installation-specific export settings. Project metadata returned through MCP is available to your client; its handling depends on the client you choose.
The polling script occupies WinOLS while it runs. Create a
stop file in the mailbox to end the loop before using
WinOLS interactively:
New-Item -ItemType File -Path C:\winols-mcp-mailbox\stop
Inspect the definition and save the project manually. Before a new
session, stop the MCP client, remove the stop file, then
restart the bridge and client. Obtain a fresh project ID before
creating another definition.
Definition format
Maps are contiguous, row-major integer layouts. Addresses are
zero-based byte offsets within the project binary. Physical values
use raw * factor + offset; X-axis length follows
columns and Y-axis length follows rows.
{
"name": "Synthetic demonstration map",
"address": 256,
"columns": 4,
"rows": 2,
"data_type": "u16_le",
"factor": 0.1,
"offset": 0.0,
"unit": "demo"
}
Pass this object as definition to validation and
creation. Creation also requires expected_project_id from
winols_get_project. Supported storage types are
u8, i8, and signed or unsigned 16- and
32-bit integers in little- or big-endian order. Optional
x_axis and y_axis objects specify their own
address, storage type, scaling, and unit.
Each dimension is limited to 4,096, with at most 1,048,576 map cells. Floating-point, bitfield, noncontiguous, reversed, and other unsupported native layouts return errors. See the native API mapping and layout boundaries.
Creation changes unsaved map metadata in the active project. The server does not identify maps automatically, change firmware bytes, save a project, or flash an ECU. You supply and verify the intended addresses, meaning, and scaling.
If creation times out or readback is uncertain, the operation may already have completed. The server stops using that bridge connection. Inspect the project in WinOLS, stop both processes, and follow mailbox recovery before restarting or retrying.
Keep building
A Markdown reference covering the seven tools, installation, definition format, and operating boundaries.
Build the MIT-licensed server, inspect the Lua adapter, run the synthetic examples, or contribute improvements.
Trace code and references with the companion Ghidra tools. Verify source identity, address mappings, and live bytes before carrying an independently validated definition into WinOLS. Read the handoff guide.
Store diagnostic evidence with provenance, explicit uncertainty, and machine-readable API contracts.