01 / 07 — MDXAvailable

MDF4 analysis software for engineering teams.

Also a fast MF4 file viewer, with a Python SDK and MCP server.

Analyze multi-gigabyte MDF4 logs, CAN/LIN vehicle bus networks, synchronized GPS routes, and parallel comparison runs in an oscilloscope-grade workbench that AI agents can directly operate over MCP.

Request an MDX build Open the live instruments Read the docs

In pilot with Tier-1 powertrain teams

MDXrun_07.mf4 Live

Channel	A	B	Δ
t	1.80 s	5.04 s	3.23 s
v_Veh	70	177	+107
n_Eng	11,056	11,478	+422
gear	1	5	+4
r_Thr	100	100	+0

Drag cursor B · hold-last-sample reads · LTTB

Formats: ASAM MDF v3 & v4, CSV, Excel
Architecture: Memory-mapped I/O, LTTB downsampling
Automation: MCP server (12 tools) + Python SDK
API: Local REST at 127.0.0.1:5001
Agent clients: Claude, ChatGPT, Codex, Cursor, Antigravity, Gemini

Capabilities

Everything the MDF4 analysis software does, in one lab.

A1
Memory-Mapped Fast I/O
Sub-second indexing of 4GB+ vehicle logs without memory exhaustion or disk choking.
A2
Agent-Native MCP Server
Twelve tools over stdio and SSE. Drive channel extraction, statistics, plotting and event detection from Claude Code, ChatGPT, Codex, Cursor, Antigravity or Gemini.
A3
Parallel Multi-Run Comparison
Overlay multiple test runs with automatic synchronization on clutch release, throttle kick, or trigger flags — plus serial concatenation for long campaigns.
A4
Domain Event Detection
Built-in algorithms for engine misfire, gear-hunting, fuel rail transients, and full WLTP drive cycle analysis.
A5
Oscilloscope Cursor Work
Dual A/B cursors with live Δ, hold-last-sample reads, per-strip axes, mixed rasters and sample-wise navigation — the measurement habits engineers already have.
A6
Server-Side Calculated Signals
Accumulators, windowed statistics, filters and latches evaluated in the backend, so derived channels stay fast on multi-gigabyte runs.
A7
Offline GPS Route Mapping
Synchronized route playback on the timeline with bundled offline map tiles — no tile server, no network call.
A8
Calibration Map Generation
Empirical maps via Kriging, RBF and spline interpolation, rendered as interactive 2D heatmaps or 3D surfaces.

MEASUREMENT TELEMETRY & MCP SPECIFICATION

High-frequency signal telemetry with direct agent orchestration.

Synchronized Telemetry Channel Raster

MDX memory-maps raw MDF4 (MF4) container blocks without buffering uncompressed arrays into memory. Real-time LTTB (Largest Triangle Three Buckets) downsampling guarantees responsive 120 FPS scope rendering across multi-gigabyte log sessions while preserving acute transient spikes.

Channel Identifier	Physical Description	Raster Rate	Dynamic Range	Downsampling Policy	Status
`Engine Speed`	Engine Crankshaft Rotational Speed	100 Hz (10ms)	0 – 8,500 RPM	Min / Max Peak Preserving	Synchronized
`Manifold Pressure`	Intake Manifold Absolute Pressure	200 Hz (5ms)	200 – 3,200 mbar	Transient Crest Retention	Synchronized
`Lambda`	Wideband Oxygen Sensor AFR (λ)	50 Hz (20ms)	0.65 – 1.60 λ	LTTB Area Maximization	Synchronized
`Injector Pulse Width`	Bank 1 Fuel Injector Pulse Width	Crank-Triggered	0.5 – 35.0 ms	Cycle-Accurate Envelope	Synchronized

Latitude · GPS route

Where the run happened, not just when.

A trace tells you a signal moved at 12:04:31. The route tells you the car was on the ramp. MDX draws the drive from the GPS channels already in the measurement, so a moment in the run has a junction, a gradient or a stretch of rough road attached to it.

MDX · Latituderun_07.mf4 · 14,558 GPS samples

Recorded in MDX · route drawn from the run's GPS channels · map style switchable

01
From the same file
The GPS channels in the recording become the route — no export, no second tool.
02
14,558 samples
Every fix in this run is on the line, with origin and endpoint marked.
03
Position readout
Latitude, longitude and the nearest place for the point you are on, live as you move.
04
Offline tiles
Map styles from plain to satellite, and cached tiles for test sites with no signal.

Works with your assistant

Ask your AI about a measurement, not about a file.

MDX connects to the assistants engineers already use. Once connected, you ask in plain language and it works on the real recording on your machine — nothing is uploaded, and the answer comes back with numbers you can check.

Claude Code
ChatGPT
Codex CLI
Cursor
Antigravity
Gemini CLI
VS Code
Zed

01
Install MDX
One desktop install. It brings its own local service; nothing is uploaded.
02
Paste one block
Into the file below. That is the whole integration — no plugin, no export step.
03
Ask in plain language
Your assistant now lists MDX as a tool and can open your measurements.

Setup · pick your assistant

Add this to ~/.claude.json Claude Code & Claude Desktop stdio

~/.claude.json

{
  "mcpServers": {
    "vehiclelab-mdx": {
      "command": "/usr/local/bin/vehiclelab-mdx",
      "args": ["mcp", "--mmap-pool-mb=8192"],
      "env": { "ASAM_MDF4_ROOT": "/data/telemetry" }
    }
  }
}

Add this to ChatGPT ChatGPT desktop · custom connector SSE

ChatGPT

Name         VehicleLab MDX
MCP Server   http://localhost:8000/sse
Auth         None (loopback only)

# Start the local endpoint first:
$ vehiclelab-mdx mcp --transport sse --port 8000

# ChatGPT reaches the loopback endpoint from the desktop app.
# Nothing is uploaded: the measurement stays on the machine and
# only the tool result crosses the connector.

Add this to ~/.codex/config.toml OpenAI Codex CLI stdio

~/.codex/config.toml

[mcp_servers.vehiclelab-mdx]
command = "/usr/local/bin/vehiclelab-mdx"
args    = ["mcp", "--mmap-pool-mb=8192"]

[mcp_servers.vehiclelab-mdx.env]
ASAM_MDF4_ROOT = "/data/telemetry"
MDX_DBC_INDEX  = "/data/dbc/powertrain_can_v4.dbc"

Add this to .cursor/mcp.json Cursor stdio

.cursor/mcp.json

{
  "mcpServers": {
    "vehiclelab-mdx": {
      "command": "vehiclelab-mdx",
      "args": ["mcp"],
      "env": { "ASAM_MDF4_ROOT": "\${workspaceFolder}/logs" }
    }
  }
}

Add this to mcp_config.json Google Antigravity stdio

mcp_config.json

{
  "mcpServers": {
    "vehiclelab-mdx": {
      "command": "vehiclelab-mdx",
      "args": ["mcp"],
      "env": { "ASAM_MDF4_ROOT": "/data/telemetry" }
    }
  }
}

Add this to ~/.gemini/settings.json Gemini CLI stdio

~/.gemini/settings.json

{
  "mcpServers": {
    "vehiclelab-mdx": {
      "command": "vehiclelab-mdx",
      "args": ["mcp"],
      "timeout": 30000
    }
  }
}

Add this to .vscode/mcp.json VS Code & GitHub Copilot stdio

.vscode/mcp.json

{
  "servers": {
    "vehiclelab-mdx": {
      "type": "stdio",
      "command": "vehiclelab-mdx",
      "args": ["mcp"]
    }
  }
}

Add this to settings.json Zed stdio

settings.json

{
  "context_servers": {
    "vehiclelab-mdx": {
      "source": "custom",
      "command": "vehiclelab-mdx",
      "args": ["mcp"]
    }
  }
}

What you can ask for

01
Open a run
Point it at an MDF4 file and it reports what is in there: channels, rasters, length.
02
Pull channels
Ask for a signal over a time window and get the samples, each at its own raster.
03
Compare runs
Two files aligned on an event, with the differences read back as numbers.
04
Find events
Misfire, gear hunting, fuel cut-off and drive-cycle windows, detected not eyeballed.

ONE LAB, TWO OPERATORS

The engineer and the agent drive the same instrument.

There is no “AI mode”. The MCP tools and the scope surface sit on one core — the same memory-mapped index, the same calculated-signal engine, the same event detectors. An agent can find the window; you put the cursor on it. Or the reverse.

HUMAN LANE

OpenDrop in an MDF4, CSV or Excel file — or a legacy display config.
ArrangeStrips, axes and rasters; overlay a second run for comparison.
MeasureA / B cursors, live Δ, hold-last-sample reads, calculated signals.
ConcludeExport the window, the numbers and the plot into the report.

AGENT LANE

ConnectOne MCP config block; the client discovers all twelve tools.
ScanList channels, pull statistics, sweep a whole folder of runs.
DetectFind events, then find every window that looks like them.
DraftReturn plots and numbers you can check against the scope.

Workflow

From input to decision.

01
Load & Index
Memory-map MDF4, BLF, ASC and CSV logs, parse channel hierarchies, and resolve DBC signal aliases in sub-second time.
02
Trace & Cursor
Inspect high-speed channels with dual time/voltage cursors, FFT spectrum, and synchronized GPS route overlays.
03
Agent Automate
Hand telemetry to local or remote AI agents over MCP to automatically detect anomalies and generate report summaries.

Why it exists

Built for the dyno cell, the test track, and the AI agent.

MDX bridges high-frequency automotive measurement with agentic intelligence. Whether you are scrubbing transient boost spikes at the test bench or asking an LLM to compare drive cycles over MCP, MDX keeps every byte local, private, and fast.

Packaged with Tauri, MDX bundles its own backend and ships offline map tiles for GPS route visualization. No data leaves the machine unless you explicitly configure an external AI endpoint.

Positioning

MDX vs legacy desktop tools.

Capability	Legacy desktop viewers	MDX Lab
Large file performance	Slow loading / high RAM	Sub-second loading, memory-mapped
UI modernity	Legacy desktop widgets	Modern web-first responsive
Deployment flexibility	Windows desktop only	Web, desktop, or portable EXE
Automation / scripting	Proprietary API	Python / JS / REST native
AI diagnostics	Manual analysis only	Built-in DiagAI assistant, private-deployable
Multi-file comparison	Manual overlay, no alignment	Serial concat + parallel overlay with sync-signal auto-align
Calculated signals	Basic formula editor	Server-side engine — accumulators, windowed stats, filters, latches
GPS & location	Not built-in	Offline route mapping on the timeline

Questions

Asked by engineers, answered plainly.

Is there an MDF4 MCP server an AI agent can drive?

Yes. MDX ships a built-in MCP (Model Context Protocol) server exposing 12 tools — health checks, log management, signal statistics, plotting, event and similar-event detection, and legacy config import. Any MCP client (Claude Code, Claude Desktop, Codex, VS Code, Gemini) connects to the local SSE endpoint with a single config block, then loads logs, queries channels, plots signals and finds events.

Is MDX an MF4 file viewer, and what other formats does it read?

MDX reads ASAM MDF v3 and v4 (.mdf, .mf4), the Vector CAN log formats BLF (.blf) and ASC (.asc), CSV and Excel. DBC and ARXML are loaded as description files to decode bus frames into named signals, rather than as measurements. MDF files are read via memory-mapped I/O so multi-gigabyte files open without loading the full dataset into memory. Signal extraction and indexing happen automatically on import.

Is MDX an offline MDF4 analysis tool?

Yes. MDX is offline-first. The desktop application (packaged via Tauri) bundles its own backend and ships with offline map tiles for GPS route visualization. No data leaves the local machine unless you explicitly configure an external AI endpoint.

Is there an MDF4 Python SDK for automation and batch processing?

Yes. MDX exposes a documented REST API (running locally at 127.0.0.1:5001) and ships a Python SDK (mdx_client) for scripting signal queries, batch analysis jobs, anomaly detection, and map tile operations. The SDK mirrors the REST API one-to-one.

Which AI clients can connect — ChatGPT, Codex, Cursor, Antigravity?

All of them, and any other MCP client. MDX serves the Model Context Protocol over stdio and SSE, so it connects with one config block from Claude Code and Claude Desktop, ChatGPT (custom connector to the local SSE endpoint), OpenAI Codex CLI, Cursor, Google Antigravity, Gemini CLI, VS Code with GitHub Copilot, Windsurf and Zed. Nothing is client-specific: the same twelve tools appear everywhere.

If an agent drives MDX, does my measurement data leave the machine?

No. The MCP server, the REST API and the analysis core all run on loopback, and the measurement files are memory-mapped locally. An agent calls a tool and receives the result — statistics, an event list, a plot — so only that result enters the model context. Raw logs are never uploaded unless you explicitly configure an external AI endpoint.

Is MDX still usable as a normal desktop instrument, without any AI?

Yes, and that is the point. The scope surface is a complete measurement tool on its own — strips, per-signal axes, A/B cursors with live delta, hold-last-sample reads, multi-run overlay, calculated signals and export. The agent tooling is an additional way in, not a prerequisite. Engineer and agent operate the same core.

What does the MDF4 data analysis tool do beyond signal viewing?

MDX includes engine misfire detection, gear-hunting analysis, fuel and BSFC calculations, WLTP cycle analysis, and empirical calibration map generation using Kriging, RBF, and spline interpolation. Maps render as interactive 2D heatmaps or 3D surfaces. LTTB downsampling keeps rendering fast even for high-frequency signals.

Next step

Ready to accelerate your vehicle data analysis?

Bring multi-gigabyte measurement files, agent automation, and offline route mapping into one local-first lab — and let your AI agents drive it over MCP.

Request an MDX build Talk to an engineer

By task

Where MDX is used.

Go deeper

Guides and comparisons for MDX.

Works with

MDF4 analysis software for engineering teams.

Memory-Mapped Fast I/O

Agent-Native MCP Server

Parallel Multi-Run Comparison

Domain Event Detection

Oscilloscope Cursor Work

Server-Side Calculated Signals

Offline GPS Route Mapping

Calibration Map Generation

High-frequency signal telemetry with direct agent orchestration.

Synchronized Telemetry Channel Raster

Open the scope. It is the product, not a screenshot.

From the same file

14,558 samples

Position readout

Offline tiles

Install MDX

Paste one block

Ask in plain language

Open a run

Pull channels

Compare runs

Find events

The engineer and the agent drive the same instrument.

Load & Index

Trace & Cursor

Agent Automate

Built for the dyno cell, the test track, and the AI agent.

Ready to accelerate your vehicle data analysis?