URDB MCP
This MCP server provides electronics, hardware, and firmware calculators plus a product integrity database, helping AI assistants solve engineering problems and evaluate consumer product quality.
Calculators (76 tools): Perform a wide range of engineering calculations across categories like components (resistor codes, LED drivers), circuits (555 timers, op-amps), power & wiring (PCB traces, wire gauge), firmware (UART, CAN, CRC), RF & signals (antennas, path loss), mechanical (steppers, gear ratios), and reference (pinouts, logic levels). Each calculation returns the answer, machine-readable values, a worked derivation, and a link to the web tool.
Product Integrity Database:
Search for products by name, keyword, or category with integrity scores (0–100).
Get detailed breakdowns across seven dimensions: durability, repairability, material quality, version stability, anti-shrinkflation, firmware lock-in, and ownership integrity.
Track change history: View documented enshittification events (e.g., firmware regressions, warranty cuts) filterable by severity (low to critical).
List and filter: Browse products by category, brand, or score to find high-integrity recommendations (e.g., best-integrity laptops).
urdb-mcp
MCP server for URDB. Gives your AI assistant 76 electronics, hardware and firmware calculators — plus the product integrity database tracking downgrades, shrinkflation, warranty cuts and enshittification.
Ask "what UBRR do I need for 9600 baud on a 16 MHz AVR?" and get 103 with the error percentage and the worked derivation, instead of a plausible-sounding guess.
Setup
1. Get an API key at urdb.io/settings/api-keys (free tier available)
2. Add to your MCP host
Claude Desktop config lives at ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows).
{
"mcpServers": {
"urdb": {
"command": "npx",
"args": ["urdb-mcp"],
"env": {
"URDB_API_KEY": "urdb_live_your_key_here"
}
}
}
}3. Restart your host
Calculators are metered separately from product data — 1,000 calculator calls a day on the free tier, so an agent working through a design won't exhaust your quota on arithmetic.
Related MCP server: OrigeneMCP
Example prompts
"Size the current-limiting resistor for a blue LED on 5 V"
"Give me every valid CAN bit timing for 500 kbit/s on a 40 MHz clock"
"What trace width do I need for 3 A with a 20 °C rise on an external layer?"
"Decode this struct's padding for a 32-bit target"
"Is 1000 km realistic on LoRa SF12?"
"Which laptops have the highest integrity scores?"
"Has the KitchenAid Stand Mixer gotten worse over the years?"
Tools
Call tools/list to see the current set — the calculator catalogue is fetched from the server at runtime, so it grows without a package update.
Calculators
76 tools across seven categories, named calc_<name>:
Category | Covers |
Components (11) | Resistor and capacitor colour/SMD codes, E-series snapping, LED resistors, RC time constants, series/parallel networks |
Circuits (16) | 555 timers, op-amps, filters, buck/boost converters, MOSFET gate drive, Ohm's law, zener and LM317 regulators, Schmitt triggers |
Power & Wiring (13) | PCB trace width and impedance, wire gauge, voltage drop, fuse sizing, heat sinks, battery packs, solar sizing, via current |
Firmware (22) | UART baud rates, CAN bit timing, PLL dividers, timer prescalers, CRC, IEEE 754, struct padding, bitfields, watchdogs, Intel HEX |
RF & Signals (7) | Antenna lengths, LoRa airtime, path loss, VSWR, Nyquist, FFT bins, wavelength |
Mechanical (4) | Stepper motors, E-steps, gear ratios, tap drill sizes |
Reference (3) | Pinouts, logic levels, MCU comparison |
Each returns the answer, machine-readable values, the worked derivation and a link to the same tool on the web at https://urdb.io/tools/<name>.
Product data
Tool | Description |
| Search products by name or keyword, with integrity scores |
| Full integrity breakdown across 7 dimensions |
| Documented enshittification events for a product |
| List/filter products by category, brand, score |
How it works
This package is a thin stdio→HTTPS proxy for https://urdb.io/api/v1. It contains no calculation logic: the catalogue and every tool's JSON Schema are fetched from /api/v1/tools when the server starts.
That means a calculator added to URDB shows up here on your next restart, and a fix reaches you via a deploy rather than npm update. If the API is unreachable the server still starts and serves the product tools, and retries the catalogue on the next tools/list.
Calculators follow published standards where one exists — IPC-2221 and IPC-2141 for trace geometry, IEC 60063 for E-series, IEC 60127 for fuses, ISO 11898-1 for CAN, IEEE 754 for floats. Where a result is an extrapolation rather than a measurement, the tool says so.
REST API
Everything here is available over plain HTTP:
curl -H "Authorization: Bearer $URDB_API_KEY" https://urdb.io/api/v1/tools
curl -X POST https://urdb.io/api/v1/tools/uart-baud-rate \
-H "Authorization: Bearer $URDB_API_KEY" \
-H "Content-Type: application/json" \
-d '{"clockHz": 16000000, "baud": 9600, "family": "avr-normal"}'Full docs: urdb.io/api
Configuration
Variable | Required | Description |
| yes | Your key from urdb.io/settings/api-keys |
| no | API base URL. Defaults to |
Development
npm run typecheck
npm run build # bundle to dist/index.js
npm test # stdio end-to-end against a mock APILicense
MIT
Available Tools
4 toolsurdb_get_changesA
Get documented enshittification events for a product — firmware regressions, warranty cuts, added subscriptions, material downgrades. All sourced and evidence-backed.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Product slug from URDB | |
| severity | No | Filter to this severity level |
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 discloses key behavioral traits: the tool returns 'documented', 'sourced and evidence-backed' events, and lists specific event types (firmware regressions, warranty cuts, etc.). However, it lacks details on permissions, rate limits, pagination, or response format.
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?
The description is a single, dense sentence with zero waste—every word contributes to clarifying the tool's purpose and scope. It is appropriately sized and front-loaded with the core action.
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?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is largely complete for its purpose. It covers what the tool does and the nature of the data, but lacks output details (e.g., response structure) and some behavioral context (e.g., error handling).
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 description coverage is 100%, so the schema already documents both parameters (slug and severity). The description adds no additional parameter semantics beyond what the schema provides, such as examples or usage nuances, meeting the baseline for high schema coverage.
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?
The description clearly states the tool's purpose with specific verbs ('Get documented enshittification events') and resources ('for a product'), and distinguishes it from siblings by specifying the type of data returned (evidence-backed degradation events) rather than general product information or listings.
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 provides clear context for when to use this tool (to retrieve documented product degradation events), but does not explicitly state when not to use it or name alternatives among the sibling tools (urdb_get_product, urdb_list_products, urdb_search).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
urdb_get_productB
Get full integrity breakdown for a specific product — scores across 7 dimensions (durability, repairability, material quality, version stability, anti-shrinkflation, firmware lock-in, ownership integrity), plus change event and recall counts.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Product slug from URDB (e.g. 'fairphone-6', 'framework-laptop-13') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the output content (scores, counts) but omits critical behavioral traits like whether this is a read-only operation, rate limits, authentication needs, error handling, or response format. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
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?
The description is a single, efficient sentence that front-loads the core action and resource, then details the 7 dimensions and additional data without waste. Every part earns its place by providing essential context, making it appropriately sized and well-structured.
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?
Given the tool's complexity (detailed multi-dimensional scoring) and lack of annotations and output schema, the description is partially complete. It explains what data is returned but misses behavioral aspects like safety, performance, and response structure. For a tool with no structured output, more guidance on return values would improve completeness.
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 description coverage is 100%, so the schema already documents the single parameter 'slug' with a clear description. The description adds no additional parameter semantics beyond implying it's for a 'specific product', which is redundant with the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
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?
The description clearly states the specific action ('Get full integrity breakdown') and resource ('for a specific product'), distinguishing it from siblings like 'urdb_list_products' (list) and 'urdb_search' (search). It explicitly details the 7 dimensions and additional data (change event and recall counts), making the purpose highly specific and differentiated.
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 provides no guidance on when to use this tool versus alternatives like 'urdb_list_products' or 'urdb_search'. It implies usage for detailed product analysis but lacks explicit when/when-not instructions or prerequisites, such as needing a product slug from another tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
urdb_list_productsB
List products filtered by category, brand, or score range. Use for recommendations like 'best integrity laptops' or 'washing machines above 70'.
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Category name (e.g. 'Laptop', 'Washing Machine') | |
| brand | No | Brand slug (e.g. 'apple', 'samsung', 'framework') | |
| min_score | No | Minimum integrity score (0-100) | |
| sort | No | Sort order — 'score' returns highest integrity first | |
| per_page | No | Results per page (max 100) |
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 of behavioral disclosure. It mentions filtering and sorting capabilities but lacks details on critical behaviors like pagination handling (implied by 'per_page' but not explained), rate limits, authentication needs, or what the output looks like (e.g., list format, error cases). This is a significant gap for a tool with multiple parameters and no output schema.
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?
The description is highly concise and well-structured, consisting of two sentences that efficiently convey the tool's purpose and usage examples without any wasted words. It is front-loaded with the core functionality.
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?
Given the tool's complexity (5 parameters, no annotations, no output schema), the description is incomplete. It lacks information on behavioral aspects like pagination, error handling, and output format, which are crucial for effective tool invocation. The examples help but don't compensate for these gaps.
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 description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by mentioning filtering by 'category, brand, or score range' and providing usage examples, but it doesn't explain parameter interactions or additional semantics. Baseline 3 is appropriate when the schema does the heavy lifting.
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?
The description clearly states the tool's purpose as 'List products filtered by category, brand, or score range,' which is a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from sibling tools like 'urdb_search' or 'urdb_get_product,' which likely have overlapping or related functionality.
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 provides clear usage context with examples like 'best integrity laptops' or 'washing machines above 70,' which helps understand when to use this tool. However, it doesn't explicitly state when not to use it or mention alternatives among the sibling tools, such as when to choose 'urdb_search' instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
urdb_searchA
Search URDB for consumer products by name or keyword. Returns products with integrity scores (0-100). Use this first when the user asks about a product or wants product recommendations.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Search query (product name, brand, or keyword) | |
| category | No | Filter by category, e.g. 'Laptop', 'Smartphone', 'Refrigerator' | |
| min_score | No | Minimum integrity score (0-100). Use 70+ for high-integrity results. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool returns products with integrity scores (0-100), which is useful context. However, it doesn't disclose important behavioral aspects like whether this is a read-only operation, potential rate limits, authentication requirements, pagination behavior, or what happens with empty results. The description adds some value but leaves significant gaps.
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?
The description is perfectly concise with two sentences that each earn their place. The first sentence states the purpose and output, while the second provides clear usage guidance. There's zero waste or redundancy, and the information is front-loaded appropriately.
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 search tool with 3 parameters, 100% schema coverage, but no annotations and no output schema, the description provides adequate but incomplete context. It covers the purpose and primary use case well, but lacks details about the return format (beyond mentioning integrity scores), error conditions, or behavioral constraints. The description is sufficient for basic use but leaves important operational questions unanswered.
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 description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions searching 'by name or keyword' which aligns with the 'q' parameter, but provides no additional syntax, format, or usage details. Baseline 3 is appropriate when the schema does the heavy lifting.
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?
The description clearly states the tool's purpose with specific verbs ('Search URDB for consumer products') and resources ('consumer products'), and distinguishes it from siblings by mentioning it's for searching by name/keyword rather than getting specific products or lists. It explicitly mentions the integrity score output, which differentiates it from basic search tools.
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 provides explicit guidance on when to use this tool ('Use this first when the user asks about a product or wants product recommendations'), creating a clear priority over other tools. While it doesn't explicitly mention when NOT to use it or name alternatives, the 'first' directive strongly implies this is the primary search tool in the context.
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. Dates show when Glama detected each change.
4 tool updates
v1.0.0- First observed
urdb_get_changes - First observed
urdb_get_product - First observed
urdb_list_products - First observed
urdb_search
TDQS
Each tool has a clearly distinct purpose: urdb_get_changes retrieves documented events, urdb_get_product provides detailed integrity breakdowns, urdb_list_products filters products for recommendations, and urdb_search finds products by name/keyword. There is no overlap in functionality, making tool selection straightforward for an agent.
All tool names follow a consistent urdb_verb_noun pattern with snake_case, such as urdb_get_changes, urdb_get_product, urdb_list_products, and urdb_search. This predictability enhances readability and usability across the tool set.
With 4 tools, the server is well-scoped for its purpose of providing product integrity data. Each tool serves a specific function—retrieving changes, product details, filtered lists, and searches—without being overly sparse or bloated, making the count appropriate for the domain.
The tool set offers complete coverage for the URDB domain: it supports searching and listing products, retrieving detailed integrity breakdowns, and accessing change events. This covers the core workflows of product discovery, evaluation, and historical tracking without obvious gaps.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Search 120,000+ recalled products from 8 global safety agencies using AI similarity.
Search 86 US retailers — 260M+ products with real-time pricing, stock, and price history.
Is it recalled or fake? Recall lookup vs live US gov feeds + transparent counterfeit risk signal.
Search uneed.best's curated product directory: launches, rankings, deals and alternatives
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server that retrieves product data from the DummyJSON API, supporting filtering by various parameters like ID, title, category, brand, price and rating.116ISC
- FlicenseNot gradedqualityDmaintenanceAn advanced integrated MCP server platform that combines 600+ tools and multiple biomedical databases to enable comprehensive information retrieval across molecules, proteins, genes, and diseases for accelerating therapeutic research.38-
- AlicenseAqualityCmaintenanceSearch ethical, origin-verified products and brands from 30+ countries. Find Canadian, sustainable, vegan, and cruelty-free alternatives with affiliate purchase links.662MIT
- AlicenseNot gradedqualityCmaintenanceProvides access to Korean government public comparison test data, including product rankings, safety ratings, and recall information from Korea Consumer Agency and Consumer24. Enables agents to search and retrieve verified test results and official sources.MIT
Appeared in Searches
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/GetMystAdmin/urdb-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server