hardwaremcp
Helps agents find MCP servers for Arduino and related microcontroller hardware (ESP32, RP2040), returning install commands and client configs for the matching hardware servers.
Includes Home Assistant among the covered device/integration families, so an agent can look up MCP servers for connecting to a Home Assistant setup, complete with install commands and client config.
Covers OctoPrint as a 3D-printer platform (alongside Bambu, Prusa and Klipper), letting agents find and get install details for MCP servers that drive OctoPrint-managed printers.
Covers Raspberry Pi as a supported hardware family, letting agents search and get recommendations for MCP servers that work with Pi-based projects.
Lists Zigbee (along with serial/BLE and lab gear) as a supported hardware family, enabling agents to discover MCP servers for Zigbee device and network control.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@hardwaremcpwhich MCP server should I use for my Bambu P1S?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
hardwaremcp
Remote endpoint: https://hardwaremcp.khanex.ai/mcp. Paste it into any MCP client: no install, no API key.
Ask your agent "which MCP server should I use for my Bambu P1S?" and it gets the right server, install commands and client config from the HardwareMCP catalog.
An MCP server that helps your AI agent find MCP servers for physical hardware: ESP32, Arduino, Raspberry Pi, RP2040, 3D printers (Bambu, Prusa, Klipper, OctoPrint), Home Assistant, cameras (Frigate, UniFi Protect, ONVIF), Zigbee, serial/BLE and lab gear.
It's a thin layer over the HardwareMCP catalog: 59 servers with install commands and client configs copied from their READMEs.
Tools
Tool | What it does |
| Search the catalog. Results sorted by GitHub stars. |
| Full details: what it does, requirements, install commands, client config snippet. |
| Every device family with server counts. |
| Top picks for a device or model (e.g. "Bambu P1S", "Voron", "ESP32-S3"), optionally ranked by a goal. |
Related MCP server: agentalmanac-mcp
Use the hosted server (no install)
Endpoint: https://hardwaremcp.khanex.ai/mcp (Streamable HTTP, stateless, no auth, CORS open, JSON responses). POST handles JSON-RPC, OPTIONS returns 204 with CORS headers, and GET/DELETE return 405 because there are no sessions or server-initiated streams.
Claude Code
claude mcp add --transport http hardwaremcp https://hardwaremcp.khanex.ai/mcpCursor (~/.cursor/mcp.json)
{ "mcpServers": { "hardwaremcp": { "url": "https://hardwaremcp.khanex.ai/mcp" } } }Claude Desktop (claude_desktop_config.json)
{ "mcpServers": { "hardwaremcp": { "command": "npx", "args": ["-y", "mcp-remote", "https://hardwaremcp.khanex.ai/mcp"] } } }Grok Bot (desktop app): there's no settings field for MCP URLs. In a Bot chat, send:
Add a custom MCP server named hardwaremcp at https://hardwaremcp.khanex.ai/mcpConfirm when asked (no sign-in needed), then type @ and pick hardwaremcp. (Cursor forum answer)
Muse (Meta): ask Muse in chat to create a Custom Connector (Meta Help Center):
Create a Custom Connector for a new remote MCP server, then connect to it:
- Name: hardwaremcp
- Transport: remote streamable HTTP
- URL: https://hardwaremcp.khanex.ai/mcp
- Auth: none (public, no API key or OAuth)
Then list its tools and call list_devices to confirm it works.Run locally (stdio)
npx -y hardwaremcp # once published to npm{ "mcpServers": { "hardwaremcp": { "command": "npx", "args": ["-y", "hardwaremcp"] } } }Develop
npm install
npm run gen-data # regenerate src/data.ts from ../hardwaremcp/data/servers.json
npm run build
npm test # scripted client over stdio
node test-client.mjs https://hardwaremcp.khanex.ai/mcp # against the live endpointCaveat
Install commands come from each project's README and haven't been bench-tested by HardwareMCP. Review code before giving an agent access to your hardware.
License
MIT
Listed in
Official MCP Registry as
io.github.saadvz/hardwaremcpGlama, via
glama.json
Available Tools
4 toolsget_serverAInspect
Get full details for one server by slug: what it does, requirements, install commands, notes, and the MCP client config snippet copied from its README.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Server slug from search_servers, e.g. 'griches-bambu-mcp' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does disclose the substantive return contents (requirements, install commands, notes, README config snippet), which is valuable given there is no output schema, but it says nothing about behavior for an unknown/invalid slug, whether the README snippet is always present, or any auth/rate constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One front-loaded sentence that states the operation and then lists the payload, with no filler or redundant restatement of the tool name. Every clause conveys what the caller receives.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool with no output schema, enumerating the returned fields is the key missing piece and the description supplies it. Only edge behavior (missing/invalid slug, optional vs guaranteed sections) is left unspecified, which is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter, and the schema already documents it at 100% coverage including the source of the value ('from search_servers') and a concrete example. The description's 'by slug' adds only marginal reinforcement, so the baseline for a single fully-documented param applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb ('Get') plus resource ('one server by slug') with an explicit enumeration of the returned content: what it does, requirements, install commands, notes, and the MCP client config snippet. The 'by slug' scoping clearly separates it from the sibling search_servers, which returns sets rather than one record.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the schema's slug description ('Server slug from search_servers') chains this tool after a search, which suggests the workflow, but the description itself states no when-to-use condition, no alternative, and no exclusions. Adequate but leaves routing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_devicesAInspect
List every device family in the catalog with how many MCP servers support it.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It usefully reveals the return content (device families plus support counts), but says nothing about ordering, pagination, or whether counts are per-family totals — gaps that are minor given a zero-parameter read-only enumeration with no side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that names the action, the scope, and the returned data with zero filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description must convey return values, and it does so ('how many MCP servers support it'). It stops short of clarifying how those counts are aggregated or whether the list is exhaustive/ordered, leaving a small but real gap for a tool with no other documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so per the rubric the baseline is 4. There are no parameter semantics to clarify and the description correctly spends no space on them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('List') and resource ('every device family in the catalog') and even names the returned payload (support counts). It does not explicitly contrast itself with siblings like recommend_for_device or search_servers, so an agent gets a clear purpose but no routing cue.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no when-to-use, when-not-to-use, or alternative-tool guidance. A reader can infer this is a catalog-enumeration helper that likely feeds recommend_for_device, but nothing in the text states that relationship or any precondition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recommend_for_deviceAInspect
Recommend the best MCP servers for a specific device, optionally for a goal (e.g. 'monitor prints', 'flash firmware', 'control lights'). Prefers maintained servers with ready client configs.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | No | ||
| device | Yes | Device name or model, e.g. 'Bambu P1S', 'ESP32-S3', 'Klipper', 'Philips Hue' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It usefully reveals the selection heuristic ('Prefers maintained servers with ready client configs'), which tells the agent how results are ranked, but says nothing about return format, result count, or whether the recommendation is deterministic.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences with the core action front-loaded and the selection heuristic appended. No filler; every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a lightweight read-only recommendation tool with no output schema or annotations, the description covers purpose, the optional goal, and the ranking heuristic. Minor gaps remain around result volume and output shape, but nothing critical for correct invocation is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% (only 'device' is documented), so the description must compensate, and it does so by providing concrete goal examples ('monitor prints', 'flash firmware', 'control lights') that clarify the otherwise-undocumented 'goal' parameter. The 'device' parameter is already well covered by the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Recommend') and a specific resource ('MCP servers'), scoped to 'a specific device' with an optional goal. This clearly differentiates it from the lookup-oriented siblings (list_devices, search_servers, get_server), though it never names them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The goal examples ('monitor prints', 'flash firmware', 'control lights') imply intended usage contexts, but there is no explicit when-to-use guidance or distinction from search_servers, which could plausibly serve a similar need. Usage is left implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_serversAInspect
Search the HardwareMCP catalog of MCP servers for physical hardware (ESP32, Arduino, Raspberry Pi, 3D printers like Bambu/Prusa/Klipper/OctoPrint, Home Assistant, cameras, Zigbee, serial, oscilloscopes). Returns matching servers sorted by GitHub stars.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Free-text search, e.g. 'bambu', 'flash firmware', 'frigate'. Use '' with a device/category filter to list all. | |
| device | No | Device filter, e.g. 'esp32', 'Bambu X1C', 'Home Assistant' | |
| category | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It usefully discloses sort order ('sorted by GitHub stars') and the return shape ('matching servers'), but says nothing about pagination, result limits, auth requirements, or what happens on zero matches.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two dense sentences, front-loaded with the verb and resource, and the parenthetical hardware examples serve a real disambiguation purpose rather than padding. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description does well to state that it returns matching servers sorted by GitHub stars. For a 3-parameter search tool this is nearly complete; only pagination and result limits are unaddressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67%, and the schema itself already documents all three parameters with examples. The description's hardware list ('ESP32, Arduino, Raspberry Pi, Bambu/Prusa/Klipper/OctoPrint, cameras, Zigbee, serial') adds useful domain vocabulary that hints at valid query terms, but does not clarify the free-text vs. filter distinction. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific verb and resource ('Search the HardwareMCP catalog of MCP servers') and enumerates the hardware domains it covers, which makes it clearly distinguishable from get_server or list_devices. It never explicitly contrasts itself with those siblings, so it falls just short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives device vocabulary but no when-to-use versus when-not-to-use guidance, and never names an alternative tool such as list_devices or recommend_for_device. The only usage hint ('Use '' with a device/category filter to list all') lives in the schema, not the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v0.1.0- First observed
get_server - First observed
list_devices - First observed
recommend_for_device - First observed
search_servers
TDQS
Scored across 4 tools
Each tool targets a distinct action: list_devices lists device families, search_servers searches by keyword, recommend_for_device recommends by device+goal, and get_server fetches details by slug. The only mild overlap is that both search_servers and recommend_for_device return server lists, but the descriptions clearly differentiate their inputs and purposes.
All tools use snake_case and follow a verb_noun pattern (list_devices, search_servers, get_server), with recommend_for_device being the only slight variation but still consistent with the same convention.
Four tools is well-scoped for a hardware MCP catalog: one for device families, one for recommendations, one for search, and one for details. Each tool has a clear, non-redundant role.
The surface covers discovery by device, goal-based recommendations, keyword search, and detailed server info. The only minor gap is a direct way to browse or list all servers without a query or device, but search_servers likely accommodates that.
Maintenance
Related MCP Connectors
Search and install 4,000+ security-scanned MCP servers from inside any MCP-aware AI client.
Search, vet & assemble MCP servers from your agent: verified tools, risk labels, and trust scores.
Find MCP servers, skills, plugins, agents, prompts and rules for any task.
Find MCP servers, APIs, tools and skills by intent. Free key: POST /api/agents/register
Related MCP Servers
AlicenseAqualityCmaintenanceEnables agents to discover, compare, and install other MCP servers using natural language tasks, backed by a searchable index of thousands of servers.672 npmMIT- AlicenseAqualityDmaintenanceEnables searching and retrieving details of 9,000+ MCP servers from the Agent Almanac catalog, allowing agents to discover, inspect, and install tools directly.331 npmMIT
- AlicenseNot gradedqualityAmaintenanceAI-first MCP server discovery tool that enables agents to search, inspect, and install MCP servers from multiple registries.13AGPL 3.0
- AlicenseNot gradedqualityCmaintenanceEnables cloud LLM agents to discover and invoke physical hardware on edge and IoT devices through standard MCP tools, bridging constrained device channels like UART, BLE, and Wi-Fi.3MIT