Free & open source MIT licensed

Your AI tools.
Your WinOLS workflow.

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

A structured connection to your project.

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.

Inspect the current project

Read project identity, binary size, Original/current bytes, and definitions. Paginate through maps and inspect their properties by ID.

Validate before creation

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.

Develop without WinOLS

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.

Free software, with clear requirements

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

Seven tools. One explicit workflow.

Tool schemas are exposed through MCP. The server returns structured results, including errors the client can handle.

winols_status

Check the selected backend and whether the WinOLS bridge responds.

Input: no parameters.

winols_get_project

Read the active project's ID, name, binary size, and map count.

Input: no parameters.

winols_read_bytes

Read 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_maps

List existing definitions with pagination.

Input: offset (default 0) and limit (1–100; default 50).

winols_get_map

Read one definition using an ID returned by listing or creation.

Input: id.

winols_validate_map

Check layout, axes, scaling, and bounds without creating a map. Validation does not identify map meaning or check duplicates.

Input: definition.

winols_create_map

Create a definition and verify its properties by reading them back. Reject duplicate names or map start addresses.

Input: expected_project_id and definition.

Quickstart

Build it. Connect it. Try a synthetic map.

Install Rust through rustup; the repository pins its toolchain. Windows builds also require the MSVC C++ build tools and Windows SDK.

1. Build and check the mock backend

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.

2. Register a local stdio server in your MCP client

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.

3. Ask your client to inspect and create

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.

Read Original and current bytes

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

Run the bridge inside WinOLS.

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
  1. Copy the complete 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.
  2. Open a saved synthetic test project. The adapter requires one contiguous project element starting at byte zero, a current element offset of zero, the original SHA-256 in project properties, and permission to read map structure.
  3. Export the map list as CSV with all maps and columns. Set 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.
  4. Drag winols_bridge.lua onto the target project window. Run the connection check below using the same mailbox path.
  5. Register the executable in your MCP client with --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.

Inspect and save in WinOLS

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

Make layout and scaling explicit.

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.

What creation means

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

Open code. Readable contracts.

Guide for AI clients

A Markdown reference covering the seven tools, installation, definition format, and operating boundaries.

Source & contributions

Build the MIT-licensed server, inspect the Lua adapter, run the synthetic examples, or contribute improvements.

Investigate firmware with Ghidra MCP

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.