foundry net-industrial
Summary: Forge lets agents identify and manage industrial machines, normalize multi-vendor telemetry, query operational history, build plain-English webhook automations, correct mappings, and create verifiable on-chain proofs.
Provision/retrieve stable machine identity (
mint_id+ Solana wallet) by OEM/model/serial; idempotent and auto-provisions during normalization.Normalize raw OEM telemetry into canonical FCS fields with per-field mapping IDs, persisted history, and trigger evaluation.
Query machine history with time bounds, field projection, row limits, or cheap summary aggregates.
Parse plain-English instructions into reviewable automation triggers; explicitly activate them; list, pause, soft-delete, restore, and inspect webhook delivery history.
Anchor data on Solana via
verify_on_chainusing Merkle batches or single payloads, returning Solscan verification URLs.Demo the full watch→fire→settle loop with
fire_sandbox.Submit mapping corrections and inspect OEM/field coverage before integrating.
Per the README, also predict failures/remaining life, score fleet health, calculate OEE/energy/shift reports, diagnose machines, manage alerts, list agents, and verify tamper-evident work records, with premium tools metered.
Allows anchoring work attestations on the Solana blockchain for tamper-evident records.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Forge by FoundryNet — Industrial Machine Intelligence
The cross-manufacturer industrial MCP server. Talk to any CNC, robot, or industrial machine in natural language — machine identity, telemetry normalization across 52 vendor packs in 20 verticals, plain-English automation, and tamper-evident work records.
Hosted MCP over Streamable HTTP. 36 tools wrap the Forge v1 API: provision a stable machine identity, normalize raw OEM telemetry into a canonical schema, query operational history, parse and activate plain-English automations, predict failures (TimesFM), score fleet health, and record every state-changing action as a verifiable, tamper-evident work record.
Website: https://foundrynet.io/?utm_source=github&utm_medium=readme&utm_campaign=forge-mcp-readme
Docs: https://foundrynet.io/docs?utm_source=github&utm_medium=readme&utm_campaign=forge-mcp-readme · Free key: https://foundrynet.io/signup?utm_source=github&utm_medium=readme&utm_campaign=forge-mcp-readme
MCP endpoint (Streamable HTTP):
https://mcp.foundrynet.io/mcpLegacy SSE endpoint (still served):
https://mcp.foundrynet.io/sseHealth:
https://mcp.foundrynet.io/healthServer card:
https://mcp.foundrynet.io/.well-known/mcp/server-card.json
What it does
It normalizes raw OEM telemetry from 18 manufacturer families into one canonical vocabulary with thousands of confirmed field mappings — so an agent writes against one set of field names whether the machine is a Fanuc CNC, a KUKA arm, or a Universal Robots cobot. On top of that it turns plain-English instructions into structured automations (review then activate), and records every state-changing action as a tamper-evident work record.
Related MCP server: Industrial MCP Agent Platform
Architecture
Pure HTTP proxy. Every tool is a thin wrapper around https://forge.foundrynet.io/v1/*.
No state, no shared imports with forge-prod — separate Railway service, separate
dependencies (fastmcp + httpx).
Claude Desktop / agent
│ Streamable HTTP (/mcp) — or legacy SSE (/sse)
│ Authorization: Bearer <the CALLER's Forge API key>
▼
foundrynet-mcp on Railway
│ gate: validate key → tier → cap → bind caller
│ HTTPS, Authorization: Bearer <the SAME caller's key>
│ X-Forge-Caller-Key-Id: <their forge_api_keys.id>
▼
forge.foundrynet.io/v1/* — scopes every row to that callerTenancy. The upstream call is made as the CALLER, not as this server. It used
to be made with the server's own FOUNDRYNET_API_KEY for every caller, with no
caller named: forge-prod scopes rows to the authenticated key's owner, so every
MCP tenant read and wrote inside one shared Forge account — and fleet_oee,
shift_report, list_agents and prediction_accuracy take no machine argument,
so they returned that whole account. The upstream hop now REFUSES to run when it
cannot name the caller: there is no fallback, because the only fallback is the
shared key. OAuth access tokens carry a key id but not a key, so they cannot be
presented upstream and are refused on tool calls with
tenant_context_unavailable.
POST /a2a/tasks and GET /a2a/agents go through the same gate function
(gating.enforce_call) as tools/call, by skill→tool mapping. They previously
authenticated the caller and then dispatched with no tier check, no cap and no
payment gate, which made the A2A route a free pass to the paid inference tools.
Tests and the release gate
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt pytest pytest-asyncio
.venv/bin/python -m pytest tests/ -q # 229 checks
scripts/release_gate.sh # tree, deps, import, suite, versionThe suite drives the real ASGI app over real Streamable HTTP through the real
gate; only Supabase and the upstream hop are substituted, and the upstream
substitute RECORDS requests, because what identity this server presents to
forge-prod is the thing most worth asserting. tests/test_rest_mcp_parity.py
measures free-tier parity against forge-prod's own _endpoint_to_billing_meter,
read out of its source at test time rather than copied.
CI runs the whole tree on every push and pull request
(.github/workflows/release-gate.yml, pinned to ubuntu-24.04): measured
223 passed, 6 skipped, 229 collected in 2m04s. The 6 skips are the checks
that read forge-prod's api.py off the local disk — 5 parity plus the
cost-ledger single-writer check — and they skip loudly, with their reason
printed, because forge-prod is a separate private repo and is not on the runner.
A visible skip beats a green tick over a check that was quietly dropped.
Deploying
cd ~/forge-mcp && git checkout main && git pull --ff-only && ./deploy.shNever railway up by hand. deploy.sh does seven things in order, and five of
them exist because of a specific way a deploy has gone wrong:
refuses a dirty tree or a branch that is not
main—railway upuploads the WORKING TREE, so with uncommitted changes no commit describes what ships;runs
scripts/release_gate.shand refuses if it is red. There is no override flag, deliberately;takes a deploy lock (
~/.forge-mcp-deploy.lock, atomicmkdir) so two concurrent deploys cannot race on the upload and on the verification;refuses if
railway upwould archive the wrong directory. It archives the CLOSEST LINKED project directory from~/.railway/config.json, walking UP — not$PWD. This directory once inherited$HOME's link, which names a DIFFERENT SERVICE;runs
stamp_build.py, which writesbuild_info.json(commit, dirty state,content_hashover the uploaded file set, build time);railway up --service 162115b7-…— the id is explicit, because a barerailway upresolves the service from that same ancestor link;polls
https://mcp.foundrynet.io/healthuntilbuild.commit_shortANDbuild.content_hashboth equal the stamp it just wrote, then asserts the status. Railway reporting SUCCESS only means the upload and build succeeded — a crash-looping new container leaves the OLD one serving and the deploy looks fine.content_hashis checked as well as the commit becauserailway upuploads a tree: the same commit with a different tree is a different deployment.
/health carries a build block using the same key names as forge-prod's, so
one verifier reads both services. When build_info.json is absent it says so in
words — build_info.json absent — deploy did not run stamp_build.py, with
commit, content_hash and built_at present and null — because a null that
looks like a missing field is indistinguishable from a stamped build.
Tools (36)
Identity & data: identify_machine, normalize_telemetry, query_machine_history,
get_coverage, correct_mapping. Automation: create_automation, activate_automation,
list_automations, disable_automation, delete_automation, restore_automation,
query_webhook_history. Prediction (TimesFM): predict, predict_breach, remaining_life,
predict_batch, fleet_health, detect_anomalies, machine_intelligence,
prediction_accuracy. Operations: calculate_oee, fleet_oee, energy_consumption,
shift_report, diagnose_machine, health_index. Guardrails: check_guardrail,
list_guardrails. Agents on your kernel: get_agent_card,
list_agents. Alerts: set_alert, list_alerts, delete_alert, alert_history.
Work records: verify_record. Demo: fire_sandbox (the full watch → fire →
settle loop, no card).
get_agent_card and list_agents are scoped to the agents connected to your kernel instance
(their capabilities, trust scores, and machine access) and are included in your subscription —
there is no per-call charge. They are operational tools for coordinating agents on your own
equipment, not cross-platform discovery. For cross-platform agent trust across any framework,
see Assay (assay.foundrynet.io). verify_record creates a tamper-evident, hash-verified record
of completed work.
Free tier exposes the read-only tools; metered pay-per-use unlocks the premium prediction and diagnostics tools (see https://forge.foundrynet.io/pricing?utm_source=github&utm_medium=readme&utm_campaign=forge-mcp-readme).
Connect (Claude Desktop, Cursor, any MCP client)
claude mcp add --transport http foundrynet-forge \
https://mcp.foundrynet.io/mcp \
--header "Authorization: Bearer fnet_YOUR_KEY"Or via claude_desktop_config.json with the mcp-remote bridge:
{
"mcpServers": {
"foundrynet-forge": {
"command": "npx",
"args": ["-y", "mcp-remote",
"https://mcp.foundrynet.io/mcp",
"--header", "Authorization:Bearer ${FNET_KEY}"],
"env": { "FNET_KEY": "fnet_… (get a free key at foundrynet.io/signup)" }
}
}
}Legacy SSE (--transport sse against https://mcp.foundrynet.io/sse) remains supported for
existing configs, but new integrations should use the Streamable HTTP /mcp endpoint above.
Get a free fnet_ key at https://foundrynet.io/signup?utm_source=github&utm_medium=readme&utm_campaign=forge-mcp-readme (50 normalize calls, no card).
Required environment (server-side)
Var | Required | Default |
| No longer used on the tool path | Kept for the boot-time config report only; tool calls run as the caller's own key |
| Yes for gating | unset = gating disabled, fail-open |
| No | default |
| No | with the exchange enabled: unset = issuance answers 503; key auth unaffected |
| No |
|
| No | 8080 (Railway sets this automatically) |
| No | 120 (seconds) |
Files
mcp_server.py— the server (36 tools +/health+/.well-known/mcproutes)gating.py— per-client tier gating (Free vs Pro tool/quota enforcement)server.json— MCP registry metadata (name, description, keywords, remote endpoint)smithery.yaml— Smithery listing metadatarequirements.txt—fastmcp>=3.4.5,<4,httpx>=0.27,PyJWT>=2.14.0,supabase,stripetests/— the behavioural suite (auth, tenancy, parity, idempotency, cache scope)scripts/release_gate.sh— must be green on the exact commit before a deploydeploy.sh— the only path to production; gated, locked, stamped and verifiedstamp_build.py— writesbuild_info.json; what/health'sbuildblock reportsProcfile— Railway start command (stamps, thenpython mcp_server.py).github/workflows/release-gate.yml— CI; the whole suite on push and PR
License
Proprietary (commercial). © Foundry Labs LLC. Contact: foundrynet@proton.me
Available Tools
14 toolsactivate_automationAInspect
Activate a parsed automation trigger on a machine. Call this AFTER create_automation returns a parsed_trigger and the user explicitly confirms they want to arm it.
Creates a live trigger that monitors the machine's normalized telemetry and fires the listed actions when the condition matches. Each action references a registered tool by tool_id; on fire, the tool's webhook is POSTed with {{variable}} interpolation against the canonical data context (mint_id, oem, model, serial, site, field, value, threshold, plus every canonical field on the matched record).
Inputs: machine_id mint_id ("MINT-…") or internal_id; resolved to canonical mint_id name short human label, ≤ 80 chars (e.g. "high spindle load") condition simple {field, op, value|threshold} OR compound {all: [...]} ops: >, <, >=, <=, ==, != actions list of {tool_id, payload_overrides?, headers_overrides?} enabled defaults to true; pass false to create the trigger paused
Returns the persisted trigger row including id (use it later to
pause/edit/delete via the Forge API). Once active, the trigger fires
on every subsequent normalize_telemetry call where the condition
matches — no further activation needed.
USE WHEN: the user has reviewed the parsed_trigger from create_automation and said something like "yes, activate it" / "go ahead" / "arm it." Never call this tool without explicit confirmation — it changes machine behavior in a way the user can feel (real Slack messages, real ERP work orders).
Inputs: name (required), actions (required), condition (required), machine_id (required), +1 more. Returns: object
correct_mappingAInspect
Teach Forge the RIGHT canonical field for a source column that normalize_telemetry mapped wrong (or abstained on). Each correction is recorded as a corpus-improvement signal the retrainer uses to fix the mapping for everyone — so every agent interaction makes normalization better.
USE WHEN: you or the user can see normalize_telemetry returned the wrong canonical for a field (e.g. it mapped an oil-pressure column to a tire- pressure field), or it abstained on a field whose meaning you know.
source_field: the raw column name exactly as it appeared in your data.
confirmed_canonical: the canonical field it SHOULD map to.
original_canonical: what normalize_telemetry actually returned (pass the
canonicalfrom that field's entry; use "abstained" if it abstained).oem: the OEM you passed to normalize_telemetry (improves aggregation).
mapping_id: optional — the
mapping_idfrom the normalize_telemetry field entry. If omitted it is derived deterministically from (source_field, oem).
Returns {ok, feedback_id, action:"correct"}. Corrections feed an offline retrain (they don't hot-patch the live corpus), so noisy feedback can't poison other users' mappings.
Inputs: source_field (required), original_canonical (required), confirmed_canonical (required), oem, +3 more. Returns: object
create_automationAInspect
Set up automated monitoring + actions for an industrial machine using natural language. Connect machine telemetry to any business system — ERP, CMMS, MES, Slack, Teams, email, Zapier, n8n — via webhooks already registered as tools on the Forge service.
Examples of instruction:
"Alert maintenance Slack when spindle load exceeds 90 percent."
"Create a Fiix work order when coolant temperature stays above 35°C
for five minutes."
"Notify the supervisor when part_count hits 500."
"When the maintenance_type changes to CORRECTIVE, post to the ops
channel."
Returns a parsed_trigger JSON for HUMAN review — DOES NOT
auto-activate. The caller (you, with user confirmation) must
explicitly POST the parsed_trigger to /v1/triggers on the Forge API
to actually create it. The response includes
confirmation_required: true and may include notes if the parser
had to make a fuzzy match (e.g. resolved an ambiguous field name to
its closest canonical match).
USE WHEN: a user wants to set up monitoring, alerts, or automations for machine state transitions. Always show the parsed_trigger to the user verbatim and ask "Confirm to activate?" before they activate it.
Inputs: mint_id (required), instruction (required). Returns: object
delete_automationAInspect
Soft-deletes the trigger (recoverable for 30 days via restore_automation). The trigger immediately stops evaluating against /v1/normalize calls and is hidden from list_automations, but the row persists with deleted_at set so an accidental delete can be undone. Use restore_automation to undo. For permanent deletion, the API supports ?permanent=true.
Past forge_trigger_executions rows for this trigger remain in either case (audit trail).
USE WHEN: the user wants to remove an automation they no longer need — "delete the coolant alert," "remove that trigger." Safer than hard delete because misclicks are recoverable; tell the user about restore_automation if they later change their mind.
Inputs: trigger_id (required). Returns: object
disable_automationAInspect
Pause an automation trigger without deleting it. The trigger stops
evaluating against incoming /v1/normalize calls but its configuration
(condition, actions, history) is preserved. Re-enable later by
PATCHing /v1/triggers/{id} with {"enabled": true} (or by asking
the user to confirm and creating a follow-up tool for resume).
USE WHEN: the user wants to TEMPORARILY stop an automation — e.g. "pause the high-spindle alert during planned maintenance," "stop that alarm for now, I'll re-enable it tomorrow." Distinct from delete_automation, which is permanent.
Inputs: trigger_id (required). Returns: object
fire_sandboxAInspect
Demo the full Forge watch→fire→settle loop against a built-in sandbox endpoint. Free tier; no machine onboarding required.
The MCP server POSTs {message, condition: condition_text, ts} to its
own /sandbox/echo route — a real HTTP round-trip with a real response
body — then hashes the response and anchors it on Solana mainnet via
the MINT relay. Returns the echo body, the tx_signature, and a Solscan
verify_url.
USE WHEN: a developer is evaluating Forge and wants to feel the full loop (a webhook actually fires, a real Solana tx actually settles, the Solscan link actually verifies) without onboarding any machines or paying for the Pro tier. 10 fires lifetime per fnet_ key.
Inputs: condition_text (required), message. Returns: object
get_coverageAInspect
Ask Forge what it can normalize BEFORE you try: the recognized OEM
verticals (CNC / robot / vehicle / AMR), the canonical-field families, and
the field list per family. Optionally pass an oem to see which vertical it
resolves to and whether the cross-vertical gate will engage.
USE WHEN: starting a new integration, or deciding whether to call normalize_telemetry — confirm the machine's OEM and your fields are in coverage. Unknown OEMs still normalize (the gate just disables itself), so absence here is a soft signal, not a hard block.
Inputs: oem. Returns: object
identify_machineAInspect
Provision or retrieve a persistent on-chain identity (mint_id) for any industrial machine. Works for CNC machines, industrial robots, PLCs, additive manufacturing cells, injection molders, presses, turbines, pumps, compressors, conveyors — any equipment from any OEM: Fanuc, Siemens, Haas, DMG Mori, Mazak, Okuma, Hurco, Doosan, Makino, ABB, KUKA, Universal Robots, Yaskawa, Stäubli, FANUC Robotics, Komatsu, Caterpillar, John Deere, Trumpf, Bystronic, Amada, EMAG, Bosch Rexroth, Beckhoff, Rockwell Allen-Bradley.
Returns the mint_id (universal handle, format "MINT-xxxxxx") plus its
Solana wallet_address. Idempotent — calling again with the same
(oem, model, serial) returns the same mint_id with created: false.
USE WHEN: a user references a specific machine by OEM/model/serial and you need a stable handle to attach normalized data, automations, or on-chain settlements to. Always call this first when a new machine is introduced to the conversation, before normalize_telemetry or create_automation.
Inputs: oem (required), model (required), serial (required), site, +1 more. Returns: object
list_automationsAInspect
List all active automations / triggers configured for one machine.
Returns each trigger with: id, name, condition (field/op/value or
compound all), actions (each resolved to its tool name + url +
method), enabled state, fire_count, last_fired_at, last_error.
USE WHEN: the user asks "what automations do I have on this machine" / "show me my triggers" / "what alerts am I getting" / "what's monitoring this machine right now". Always pass the machine's mint_id (or internal_id — both resolve).
Inputs: machine_id (required). Returns: object
normalize_telemetryAInspect
Translate raw machine telemetry from any OEM's proprietary format into universal canonical FCS (FoundryNet Canonical Schema) data. Maps vendor-specific column names like "Spindle_Speed", "servo_load_x", "CoolantTemp", "FeedRateOverride" into standard fields like spindle_speed_rpm, axes.x_load_pct, sensor_readings.coolant_temp, feed_override_pct.
Accepts a data dict of {raw_field: value}. If machine_id (mint_id
or internal_id) is omitted but oem+model+serial are provided, silently
auto-provisions the machine identity (same effect as calling
identify_machine first).
Each call:
Returns canonical_data + a per-field mapping_id (use mapping_id with /v1/feedback/{mapping_id}/correct if a mapping is wrong)
Writes a row to forge_normalized_history (visible via query_machine_history)
Evaluates active triggers; the response includes a
triggers_firedarray if any condition matched. The actual webhooks fire async, so the array tells you what was triggered without blocking on remote latency.
USE WHEN: you have raw machine data — a CSV row, a sensor reading, an MES export, an alarm log line — and need to either (a) understand it semantically using canonical field names, (b) feed an automation that watches canonical fields, or (c) build up history for the machine.
Inputs: data (required), oem, site, model, +2 more. Returns: object
query_machine_historyAInspect
Retrieve operational history for an identified machine. Each row is one /v1/normalize call's canonical output (FCS field → value).
Query options: from_dt, to_dt ISO-8601 timestamps to bound the time range fields comma-separated FCS field names to project; omit for full canonical_data limit max rows (1–1000, default 100) summary true → returns aggregate stats only (row_count, time range, avg coverage_pct, fields_covered set) without the raw rows. Always cheap.
USE WHEN: a user asks how a machine has been running, wants utilization
or throughput or health trends, looks for patterns in alarms or
operational state, compares periods ("how was today vs yesterday"), or
wants to know what data is even available for a machine. Prefer
summary=true first to orient on volume + which fields are present,
then drill in with field projection on a smaller time window.
Inputs: mint_id (required), limit, to_dt, fields, +2 more. Returns: object
query_webhook_historyAInspect
Show webhook delivery history for a trigger — HTTP status codes, response times, retry counts, errors. Use to verify webhooks are actually delivering.
Returns up to limit most-recent execution rows (default 10, max 200),
each with: fired_at, http_status, attempt_count, response_time_ms,
error (if any), tool_name, target_url, and the on-chain settlement
tx (settled_tx) once the row has been Merkle-rooted via batch settle.
USE WHEN: a user asks "did the alert actually go out?" / "why didn't Slack get pinged?" / "is the trigger working?" / "show me the last few fires." Soft-deleted triggers can still be queried — useful for forensic audits after a misclick + restore.
Inputs: trigger_id (required), limit. Returns: object
restore_automationAInspect
Restore a previously soft-deleted automation trigger within its 30-day recovery window. Re-enables the trigger so it evaluates against incoming /v1/normalize calls again.
Returns the restored trigger row plus restored: true and the
restored_at timestamp. 410 (Gone) if the trigger was deleted more
than 30 days ago and is past the restorable window. 409 if the
trigger isn't actually deleted.
USE WHEN: a user accidentally deleted a trigger and wants it back. Also useful as the "undo" half of a "delete then change my mind" flow — pair with disable_automation when the user wants to pause rather than delete in the first place.
Inputs: trigger_id (required). Returns: object
verify_on_chainAInspect
Anchor data on Solana mainnet via the MINT relay for cryptographic proof of work. Two modes:
BATCH MODE (batch=true, requires mint_id):
Collects every unsettled event for that machine — normalize calls,
trigger fires, webhook executions — since the last batch. Computes
a Merkle root of their event hashes and anchors that single root on
Solana. ONE transaction proves dozens to thousands of events.
Returns: merkle_root, event_count, event_types breakdown,
tx_signature, verify_url (Solscan link). Cost-efficient — call this
once an hour or once a shift per machine, not per event.
SINGLE-PAYLOAD MODE (batch=false, requires payload):
Hashes an arbitrary JSON payload deterministically (sorted keys,
no whitespace) and anchors the hash. Returns: payload_hash,
tx_signature, verify_url. Use for one-off proofs — inspection
records, completed work orders, signed reports — where you want a
permanent independent timestamp.
USE WHEN: a user wants tamper-proof evidence — settlement of a
completed work batch, proof a maintenance window happened, anchoring
a quality report, rolling up a day's machine activity into a single
verifiable hash. ALWAYS include the verify_url (a Solscan link) in
your reply so the user can independently verify on-chain.
Inputs: batch, mint_id, payload. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Each tool has a clearly distinct purpose covering machine identity, telemetry normalization, mapping corrections, coverage checks, history queries, automation lifecycle (create, activate, list, disable, delete, restore), webhook history, sandbox demo, and on-chain verification. No two tools overlap in their core functionality.
All tools follow a consistent verb_noun pattern in snake_case (e.g., identify_machine, normalize_telemetry, create_automation). The naming is predictable and intuitive, making it easy for an agent to infer tool purpose from the name.
14 tools is well-scoped for an industrial IoT platform. Each tool addresses a specific need without unnecessary redundancy. The count supports a comprehensive workflow without overwhelming the user.
The tool set covers the core lifecycle: machine identity, telemetry normalization with correction feedback, history queries, automation CRUD plus activation/disable/delete/restore, webhook monitoring, sandbox demo, and on-chain verification. A minor gap is the lack of a dedicated re-enable tool for disabled automations, but the disable description notes it can be done via PATCH, so agents can adapt.
Maintenance
Related MCP Connectors
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
Build and run AI workflows, agents, data tables and 1000+ API integrations from any MCP client.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Unified MCP Server is a remote MCP connector for AI agents and vertical AI products that provides access to 22,000+ authorized SaaS tools across 400+ integrations and 24 categories directly inside LLMs (Claude, GPT, Gemini, Cohere). Tools operate only on explicitly authorized customer connections, enabling agents to safely read and write against live third-party systems.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn AI agent system that monitors manufacturing equipment health using the Model Context Protocol (MCP). Enables answering natural language questions about equipment status, maintenance, and anomalies through MCP tools.-
- AlicenseNot gradedqualityDmaintenanceMCP server for integrating manufacturing systems (MES/ERP/quality/maintenance) with LLM agents, enabling event ingestion, incident triage, approval workflows, and RAG-based knowledge retrieval.MIT
- AlicenseAqualityDmaintenanceMCP server that unifies real-time telemetry from industrial systems into a single queryable interface, enabling production visibility, anomaly detection, and operational insights.56 npmMIT
- FlicenseNot gradedqualityDmaintenanceEnables engineers and plant managers to interact with manufacturing systems using natural language, providing machine health analysis, KPI dashboards, predictive maintenance, and automated workflow execution via MCP.-