Skip to content

Tool of the Day|Predictive Maintenance MCP — letting an LLM read vibration signals instead of guessing

Nov 5, 20261 min
TL;DRPredictive Maintenance MCP is an MIT-licensed open-source MCP server that gives an LLM 39 tools for diagnosing bearing vibration. Install: git clone, then uv pip install . inside the project. It solves AI-assisted machine diagnostics that run on guesswork — the server refuses to infer from filenames and requires a measured frequency match before it will cite an ISO 20816-3 severity grade.

Look up & save

Loading dictionary…

🌏 中文版

Tool info

ItemValue
NamePredictive Maintenance MCP
TypeMCP server (plus a Claude Code plugin)
GitHubLGDiMaggio/predictive-maintenance-mcp
Stars108 (at time of writing)
LanguagePython 3.11+
LicenseMIT (code); the bundled sample vibration signals are CC BY-NC-SA 4.0 (non-commercial)
Installuv pip install . (inside the project directory after git clone)

What problem it solves

Rotating machinery — motors, pumps, fans — leaves a trace in its bearings' vibration signal before it fails. Reading that trace means knowing FFT, envelope analysis, and ISO 20816-3 severity grading, and not every reliability engineer carries that signal-processing background. Hand a raw vibration signal to a general-purpose LLM and ask "is this machine failing?", and the model can easily pick up on a filename or a leading question and produce an answer that sounds plausible but has no spectral evidence behind it — a risk no industrial floor can accept.

Predictive Maintenance MCP turns that judgment call into a set of constrained MCP tools, built around one hard rule: the server refuses to infer a fault from a filename or a statistical summary. A fault verdict only stands once the envelope spectrum shows, at the bearing's theoretical fault frequency, a line that actually clears the noise floor. Every severity conclusion cites the ISO 20816-3 grade, and the wording is authored by the server, not improvised by the model. The LLM's job is to orchestrate the analysis and present the evidence — the fault frequencies detected, the fault patterns matched, the severity zone — while the final call stays with the engineer.

How Predictive Maintenance MCP judges one vibration diagnosis
How Predictive Maintenance MCP judges one vibration diagnosisThe vibration signal goes through spectral analysis first; the server only moves on to ISO severity grading and a diagnostic report once it measures a matching fault frequency, and returns unknown instead of letting the model guess when it doesn't. Vibration signal + metadata FFT analysis envelope spectrum Fault frequency found? vs. noise floor ISO 20816-3 severity class Diagnostic report with matched evidence unknown insufficient evidence Yes No

Simplified: the real flow also reports the deviation and multiple candidate fault modes.

Good fit: a reliability engineer who wants to screen a batch of vibration signals in plain language and turn the result into an HTML or Word report with charts attached, or an industrial IoT team wiring existing sensor data into Claude Desktop or Claude Code for anomaly monitoring. Not a fit: anything needing real-time streaming (MQTT/Kafka) or a multi-asset fleet dashboard — both are still on the README's roadmap, not yet built.

Quick start

Install

git clone https://github.com/LGDiMaggio/predictive-maintenance-mcp.git
cd predictive-maintenance-mcp
uv venv .venv --python 3.11
uv pip install --python .venv/bin/python .

git clone pulls down 20 sample signals along with the code — real rolling-element bearing measurements from the MathWorks dataset. Installing from the PyPI package instead skips those samples. After install, add an entry to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) under mcpServers pointing at .venv/bin/python, restart Claude Desktop, and ask "list the available vibration signals" to confirm it's working.

Basic usage

The server ships 39 tools and 3 prompts covering signal loading, FFT/envelope spectral analysis, ISO severity assessment, and report generation. No coding required — just ask in plain language:

"Load real_train/OuterRaceFault_1.csv, shaft speed 1500 rpm:
check the bearing against the fault frequencies declared in
its metadata, assess ISO severity, and generate an envelope
analysis report."

What comes back isn't the model's opinion — it's measured evidence: which fault frequency lines in the envelope spectrum clear the noise floor, by how much, the corresponding ISO 20816-3 severity zone, and the path to an HTML report with those frequencies marked.

Advanced usage

Every signal is tracked from load to report under one signal_id, paired with an asset health ledger that tracks a given machine's changes over time:

declare_measurement_point   # declare a measurement point (asset, location, conditions)
declare_healthy_baseline    # declare a healthy baseline
get_asset_history           # pull an asset's measurement history
assess_asset_change         # compare the latest reading to the baseline, per the declared rule

It also installs as a Claude Code plugin, adding 8 auto-triggered diagnostic skills and 2 end-to-end agents:

/plugin marketplace add LGDiMaggio/predictive-maintenance-mcp
/plugin install predictive-maintenance@predictive-maintenance-marketplace

Compared to existing approaches

Predictive Maintenance MCPCommercial vibration analysis softwareGeneral LLM asked directly
Agent / conversational use✅ MCP-native, works with Claude or any MCP client❌ Mostly standalone GUIs✅ but no tool-enforced constraints
Data stays local✅ Raw signals never leave the machine, only results go to the LLMDepends on the vendor's deployment❌ The whole signal has to go to the cloud model
Verdicts backed by spectral evidence✅ Refuses filename guesses, requires a matched fault frequency✅ Most commercial tools do this too❌ Prone to inventing a fault that follows the prompt
Open source, reproducible benchmark✅ MIT, blind results on the CWRU dataset are rerunnable❌ Algorithms are mostly black boxes—
Licensing costFree (MIT)Often billed per machine per year, can reach tens of thousands of dollarsBilled by API usage

Things to watch out for

  • This is proof-of-concept software, not a validated field instrument. The companion academic paper (MDPI Applied Sciences) positions it as a PoC, and the README makes no claim of long-term validation on a production line. Fine for screening, but final shutdown or maintenance decisions still belong to the engineer — don't let it trigger a shutdown or work order on its own.
  • Wrong metadata means a wrong diagnosis, or unknown. The server requires the user to declare sampling rate, signal units, and shaft speed rather than guessing them from a filename. Using your own data means building a <name>_metadata.json file per data/README.md's format first; skip or misstate it and analysis either fails or falls back to a conservative "insufficient evidence."
  • Licensing is split in two layers. The code itself is MIT, but the 20 bundled sample signals are CC BY-NC-SA 4.0 (non-commercial). For a commercial deployment, swap in your own machine's vibration data — don't ship the sample data to production.

Today's takeaway

Most "AI + industrial diagnostics" demos stop at handing a signal to an LLM and seeing whether it can name a plausible fault. This project does the opposite: it uses MCP as a guardrail that keeps the LLM from freelancing. The model can only present the spectral evidence and ISO grade the server computed — it can't invent a fault. That's a useful reminder for high-stakes verticals like industry, healthcare, and finance: wiring in an LLM often isn't about making the model "judge better." It's about using the tool layer to hand judgment back to deterministic, citable logic, and letting the LLM go back to orchestrating and presenting.

References