# DatasheetVend (remote · datasheetvend.com) Turn datasheets into source-backed JSON contracts, pinout matrices, and KiCad CAD for AI agents. - Trust score: 76/100 (medium) - Change this week: +4 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-11-05 ## Components - remote · `datasheetvend.com`: 76/100 (this document), [markdown](https://verifymcp.io/servers/com-datasheetvend-datasheet-contracts/api-mcp.md), [page](https://verifymcp.io/servers/com-datasheetvend-datasheet-contracts/api-mcp) ## Channel facts - Endpoint: `https://datasheetvend.com/api/mcp` - Transports: `streamable-http` - Auth: `none` - Version: `1.1.0` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-11-05. - **Endpoint Security**: 80/100 - The endpoint's TLS certificate is valid, in date, and uses a strong key. - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one. - HTTPS is enforced; there's no plaintext access path. - The HSTS (Strict-Transport-Security) header is present. - DNSSEC check failed: this domain isn't protected by DNSSEC. - **Transport & Reachability**: 100/100 - Verified streamable-http transport via a live MCP handshake. - **Schema Quality & AI Usability**: 63/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 6905 tokens (~287/item across 24 items; 24 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 30/100 - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (100% of tools); any adoption earns full credit. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - We read all 24 captured tool definition(s), and no name or description among them implies an irreversible operation. - An AI judge read all 24 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### How do I install the DatasheetVend MCP server? DatasheetVend is a hosted endpoint at https://datasheetvend.com/api/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add --transport http com-datasheetvend-datasheet-contracts 'https://datasheetvend.com/api/mcp' ``` ### Cursor ```json { "mcpServers": { "com-datasheetvend-datasheet-contracts": { "url": "https://datasheetvend.com/api/mcp" } } } ``` ### VS Code ```json { "servers": { "com-datasheetvend-datasheet-contracts": { "type": "http", "url": "https://datasheetvend.com/api/mcp" } } } ``` ### Codex ```toml [mcp_servers.com-datasheetvend-datasheet-contracts] url = "https://datasheetvend.com/api/mcp" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "com-datasheetvend-datasheet-contracts": { "type": "remote", "url": "https://datasheetvend.com/api/mcp", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add com-datasheetvend-datasheet-contracts --url 'https://datasheetvend.com/api/mcp' --transport streamable-http ``` ### Hermes ```yaml mcp_servers: com-datasheetvend-datasheet-contracts: url: "https://datasheetvend.com/api/mcp" ``` ### Netclaw ```json { "McpServers": { "com-datasheetvend-datasheet-contracts": { "Transport": "http", "Url": "https://datasheetvend.com/api/mcp" } } } ``` ### Vellum ```bash assistant mcp add com-datasheetvend-datasheet-contracts -t streamable-http -u 'https://datasheetvend.com/api/mcp' ``` ### Other ```json { "mcpServers": { "com-datasheetvend-datasheet-contracts": { "type": "http", "url": "https://datasheetvend.com/api/mcp" } } } ``` The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs. ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-11-05 (score 76, +1) No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-11-03 (score 75, +1) No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-11-01 (score 74, +1) No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-30 (score 73, +1) No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-29 (score 72, −1) - [functional regression] Schema quality: pass → fail - [functional] First check of Tool coverage: 100 - [functional] Schema quality: good → excellent - [functional] New tool “datasheetvend_build_component_twin” - [functional] New tool “datasheetvend_decode_part_number” - [functional] New tool “datasheetvend_extract_absolute_max” - [functional] New tool “datasheetvend_extract_altium_bundle” - [functional] New tool “datasheetvend_extract_analog_specs” - [functional] New tool “datasheetvend_extract_document_map” - [functional] New tool “datasheetvend_extract_kicad_bundle” - [functional] New tool “datasheetvend_extract_kicad_footprint” - [functional] New tool “datasheetvend_extract_kicad_symbol” - [functional] New tool “datasheetvend_extract_logic_levels” - [functional] New tool “datasheetvend_extract_package_dimensions” - [functional] New tool “datasheetvend_extract_passive_bom” - [functional] New tool “datasheetvend_extract_peripheral_matrix” - [functional] New tool “datasheetvend_extract_pin_cautions” - [functional] New tool “datasheetvend_extract_pinout” - [functional] New tool “datasheetvend_extract_power_domains” - [functional] New tool “datasheetvend_extract_register_map” - [functional] New tool “datasheetvend_extract_thermal_limits” - [functional] New tool “datasheetvend_extract_timing_characteristics” - [functional] New tool “datasheetvend_get_component_twin” - [functional] New tool “datasheetvend_inspect_document_page” - [functional] New tool “datasheetvend_list_component_twins” - [functional] New tool “datasheetvend_read_document_map_instructions” ### 2026-10-28 (score 73, +1) - [functional improvement] Stability: unverified → 0.03 ### 2026-10-27 (score 72) First indexed and scored. ## MCP tools (24) ### `datasheetvend_extract_document_map` (~356 tokens) Map a datasheet (deterministic index) Build the Document Map of a datasheet PDF: a deterministic, machine-readable index of WHERE the topics live (pinout, package, mechanical, electrical, timing, thermal, absolute_max, registers, cautions …) and WHAT each page physically looks like (table / prose / vector_drawing / raster_image / blank / honest unknown), including a per-page geometry census (vector paths, ruling lines, raster coverage). No LLM is involved — the same document yields the same map, cached by SHA-256, so repeat calls are served from the cache. USE IT FIRST, before reading any page of a datasheet: read the candidate pages it recommends and pick your tool per page from anatomy.dominant_form. The result is wrapped as { contractVersion, documentRef, review, map }; inside `map` it names `map.document.total_pages` (the physical page count) and, per topic, `map.module_targets[].primary_pages` — so it answers 'how many pages' and points to the pages likely to hold the absolute-max ratings / pinout / package drawing (a primary page can miss, so read the candidates and check the warnings). Do NOT use it to get pin names, dimensions, or ratings — it contains no extracted values (use datasheetvend_extract_pinout for pins). Page numbers are physical 1-based PDF pages, not printed labels. Check review.required and the warnings before trusting a degraded map. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve).. Output parameters: - `cached` (boolean): True when served from the deterministic SHA-256 cache - `contractVersion` (string): Contract schema identifier: dmap_evidence_v1 - `documentRef` (string): Echo of the documentPath/URL that was mapped - `map` (object): The versioned Document Map agent delivery envelope (document_map_agent_v1): document.{total_pages,sha256}, module_targets[], toc[], page_grid_summary, warnings. The top-level envelope also carries `c… - `review` (object) ### `datasheetvend_read_document_map_instructions` (~80 tokens) Document Map usage instructions Return the versioned usage instructions for Document Map consumers: the binding rule (SHA-256 + physical pages), field semantics, the dominant_form action table, and the measured routing discipline. Call once per session before working with maps from datasheetvend_extract_document_map; do not call repeatedly — the text is static per contract version. Output parameters: - `instructions` (string): The Document Map markdown guidelines and dominant_form action matrix ### `datasheetvend_inspect_document_page` (~219 tokens) Inspect one mapped page (Tier-2 detail) Tier-2 detail for ONE page of an already-mapped datasheet: the full measured anatomy (text metrics, MuPDF geometry census, structural geometry signals), the page's own headings and first lines, and which modules claim the page. Use it AFTER datasheetvend_extract_document_map, when the Tier-1 index says a page matters and its one-line summary is not enough. Pass the document.sha256 from the map (served free from cache). Set include_physical=true ONLY when you truly need the raw positioned tokens/vector paths — that payload can weigh hundreds of KB for one dense page. Read-only; never rebuilds, never bills. Input parameters: - `documentRef` (string, required): The document.sha256 from a prior datasheetvend_extract_document_map result (preferred), or the same document path/URL. - `include_physical` (boolean): Include the raw MuPDF physical reconstruction (positioned tokens, vector paths). Heavy — default false. - `page` (integer, required): Physical 1-based PDF page number to inspect. Output parameters: - `cached` (boolean): Whether served from the Document Map cache - `inspection` (object): status ok: document_map_page_inspection_v1 (page, form, headings, claimed_by_modules, anatomy, physical_map) - `page` (number): status page_out_of_range: the page that was asked for - `status` (string): ok, or page_out_of_range when the map has no such page - `total_pages` (number|null): status page_out_of_range: the map's page count ### `datasheetvend_extract_pinout` (~409 tokens) Extract datasheet pinout Extract a component's pin/pad table from a datasheet PDF as verifiable, provenance-tracked evidence — not raw PDF text to re-interpret. Returns a PinoutEvidence document (contract pinout_evidence_v1): the canonical pins and special pads with names/types/functions. It also RESOLVES THE PACKAGE from the terminals — `package.family`, `package.variant` (e.g. SOT-223, TQFP-32) and `package.pin_count` — so use this tool to answer package-variant and pin-count questions, not extract_package_dimensions (mechanical geometry) or decode_part_number (ordering codes). A review-state flags when the result must be human-checked (e.g. no pins recovered, or the module raised warnings). Prefer this over reading the PDF yourself; trust `review.required` before acting. Runs DatasheetVend Fast Extraction: a page scout routes targeted reads of the pin tables, cross-checked against the package drawing where the document prints one, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot extract the pinout, the slower deep engine re-runs pinout alone (engine.runtime is then `monolith_rescue`; a rescue can take several minutes, so set a client timeout of 10 minutes). Only if that also fails does it come back as an error with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `packageSelection` (string|null): Optional package/variant (e.g. 'LQFP48') when the datasheet lists more than one; Fast Extraction reads that package's pin column. - `partName` (string|null): Optional part number / MPN to disambiguate a datasheet that covers several parts. Output parameters: - `contractVersion` (string): Contract schema identifier: pinout_evidence_v1 - `documentRef` (string): Echo of the documentPath/URL that was extracted - `engine` (object): Which engine produced this result - `evidence` (object): The pinout module's canonical output: component, package (family/variant/pin_count), pins[] with capability mappings, special_pads[], enriched_fields, normalized_output, engineering_summary, warnings. - `review` (object) ### `datasheetvend_extract_thermal_limits` (~262 tokens) Extract thermal resistance and operating limits Extract thermal characteristics: junction-to-ambient (θJA) and junction-to-case (θJC) thermal resistance, power dissipation limits, and operating/junction/storage temperature ranges — with the datasheet page where one was recorded. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_absolute_max` (~253 tokens) Extract absolute maximum ratings Extract the Absolute Maximum Ratings: never-exceed supply/pin voltages, max currents, and storage temperatures. Use extract_logic_levels for the OPERATING supply range, not these stress limits. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_logic_levels` (~262 tokens) Extract DC logic levels and operating conditions Extract DC electrical characteristics: VIH/VIL/VOH/VOL thresholds, Schmitt hysteresis, AND the VCC/VDD operating supply voltage range. Use this for supply-range questions; extract_absolute_max gives never-exceed limits. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_timing_characteristics` (~250 tokens) Extract AC timing characteristics Extract AC timing: setup/hold (tSU, tH), propagation delays, maximum clock frequencies (fMAX), rise/fall times, and bus timing. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_register_map` (~242 tokens) Extract hardware register map Extract the register map: memory addresses, reset values, access permissions (RO/RW/W1C), and per-bit field definitions. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_package_dimensions` (~278 tokens) Extract package dimensions and land geometry Extract mechanical package outline dimensions (D, E, A, A1, e, L, b) and a nominal land geometry estimate in the spirit of IPC-7351B (review-level, not a manufacturer land pattern). For the package variant/pin count from the pin table, prefer extract_pinout. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_decode_part_number` (~306 tokens) Decode manufacturer ordering part numbers Decode the ordering nomenclature: per-position suffix meanings (temp grade, package, speed, packaging) and, where the datasheet's ordering information supports it, the enumerated orderable_part_numbers list — the direct answer to 'which/how many orderable part numbers'. Codes the document's ordering legend lists that the decode lacks come back as deterministic_harvest_only_rules, each with its source page: text-layer evidence to check, not decoded rules. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_peripheral_matrix` (~418 tokens) Extract on-chip peripheral matrix Extract the on-chip peripheral inventory, one row per instance, in 13 classes: serial/communication (UART/USART, SPI, I2C, CAN, USB, Ethernet, SDIO, I2S/SAI), analog blocks (ADC, DAC, comparator, op-amp, voltage reference, temperature sensor), timers and watchdogs, DMA, security/math accelerators (crypto, RNG, CRC), external memory interfaces (FMC/FSMC/EMC, memory-mapped QSPI), display/camera/touch, interrupt controllers, GPIO, clock/reset, low-power modes, debug/trace and device identity. Each row carries the datasheet page it was read from, where one was recorded. For ADC/DAC/comparator electrical specs (resolution, sampling rate, INL/DNL, propagation delay) use datasheetvend_extract_analog_specs. For per-mode current draw, wakeup timing, and reset/brown-out threshold voltages use datasheetvend_extract_power_domains. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_analog_specs` (~325 tokens) Extract analog domain specifications (ADC/DAC, Op-Amps, VREF) Extract analog conversion and signal-conditioning specs: ADC/DAC resolution, sampling rates (MSPS/kSPS), channel counts, input-voltage ranges, static non-linearity (INL/DNL), dynamic specs (ENOB, SINAD, SNR, SFDR, THD), operational amplifiers (GBW, slew rate, rail-to-rail, CMRR/PSRR), internal voltage references (nominal voltage, tempco ppm/°C), and operating supply/temp envelopes, plus comparator propagation delay and hysteresis. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_power_domains` (~243 tokens) Extract power domains and consumption Extract power supply domains (VDD/VDDA/VBAT), low-power/sleep modes and their consumption, and battery-backup configuration. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_passive_bom` (~253 tokens) Extract passive support BOM Extract the recommended passive support components: decoupling/bypass capacitors, crystal load caps, and pull-up/down resistors, with their values and the pins they connect to. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_pin_cautions` (~336 tokens) Extract pin cautions and design rules Extract hardware design cautions: bootstrap/mode-strapping requirements, 5V-tolerant vs 3.3V-only pin boundaries, reset/debug pin precautions (NRST filtering, SWD pull-ups), oscillator/crystal PCB guardrails, analog/power-domain isolation (VDDA/VBAT), and unconnected/reserved-pin handling. Each caution row includes source_page, source_text_snippet, and verified source_evidence bounding box coordinates ([x0, y0, x1, y1] in PDF points and normalized 0..1000 space) for visual inspector auditability. Runs DatasheetVend Fast Extraction: a page scout routes targeted model reads and the module's own deterministic readers, then the same normalization and completion checks as a dashboard job finish the result, usually in seconds; `engine` names the engine on every result. If Fast Extraction cannot complete the module, the slower deep engine re-runs that module alone (engine.runtime is then `monolith_rescue`; the result says so, and it is billed as delivered). A rescue can take several minutes, so set a client timeout of 10 minutes. Only if the deep engine also cannot deliver does the module return status FAILED with the reason. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve). - `partName` (string|null): Optional part number / MPN to disambiguate a multi-part datasheet. Output parameters: - `canonical_output`: The module's canonical (CAD-ready normalized) output block. - `contract` (string): Contract id, e.g. thermal_evidence_v2 - `engine` (object): Which engine produced this result - `engineering_summary` (string|null): Concise human-readable engineering summary, when emitted. - `extracted_data`: The module's extraction after its own normalization — values with the datasheet page they came from (source_page, where one was recorded) and, where the module provides them, confidence_score and sou… - `module_id` (string): Canonical module id - `review` (object) - `status` (string): The module's completion status (for example approved, approved_with_warnings or empty), or FAILED when Fast Extraction could not extract the module - `warnings` (array): Public engineering warnings from the extraction. ### `datasheetvend_extract_kicad_footprint` (~283 tokens) Extract KiCad PCB footprint (.kicad_mod) Write a KiCad PCB footprint (.kicad_mod) from a datasheet's package mechanical drawing: pad geometry, pitch, thermal tabs and courtyard, using the datasheet's own recommended land pattern when it prints one, otherwise simplified IPC-7351B fillet math. Emitted files are loaded with kicad-cli (sym/fp upgrade) where it is installed, which is a file-format check, not a DRC or ERC. Only bundle_status "completed" (with final_readiness.physical_truth_approved true) means the placement was independently proven against this document; "needs_review" covers everything else that still produced a file, including one built from the KiCad library or JEDEC/IPC-7351B math instead of this document (see footprint_provenance). Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve).. - `packageSelection` (string|null): Optional package/variant (e.g. 'LQFP48', 'SOIC8', 'QFN32'). - `partName` (string|null): Optional part number / MPN to disambiguate package variants. Output parameters: - `bundle_status`: completed = both requested files were proven against this document. needs_review = a run finished (or a fallback file was attached) without that proof. cannot_extract = nothing usable. null = the pip… - `contract` (string): Contract schema identifier: kicad_evidence_v1 - `final_readiness`: The emit gate's full verdict. null when the pipeline never reached this stage. - `footprint_provenance`: Set only when this file did NOT come from this document's own extraction (a KiCad-library match or JEDEC/IPC-7351B math instead). null means the file was built from this document. - `human_warnings` (array) - `inputs` (object) - `kicad_mod` (string|null): Complete KiCad PCB footprint (.kicad_mod) file content, or null if withheld/not produced. - `manufacturer_part_number` (string|null): Resolved by the pipeline's identity resolution — not an echo of the input. See requested.part_name for what was sent. - `package_variant` (string|null): Resolved package code. - `requested` (object): Exactly what the caller sent, kept distinct from the resolved identity above. - `review` (object) - `status` (string): The pipeline's own run status. FAILED means nothing usable was produced and the credits for this call are refunded automatically. - `status_detail` (object) - `symbol_provenance`: Set only when this file did NOT come from this document's own extraction (a KiCad-library match or JEDEC/IPC-7351B math instead). null means the file was built from this document. - `validation`: kicad-cli file-load result (sym/fp upgrade — a format check, not a DRC). - `warnings` (array): Engineering warnings emitted during generation ### `datasheetvend_extract_kicad_symbol` (~220 tokens) Extract KiCad schematic symbol (.kicad_sym) Write a KiCad schematic symbol library (.kicad_sym) with logical pin groupings (Power, Ground, Reset, Clocks, GPIO, Analog, Bus interfaces) from a datasheet's pinout. Symbol layout is generated from the pin functions the pinout module resolved; there is no IEEE/IEC symbol-drawing standard applied. The emitted file is loaded with kicad-cli (sym upgrade) where it is installed, a file-format check, not a DRC or ERC. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve).. - `packageSelection` (string|null): Optional package/variant (e.g. 'LQFP48', 'SOIC8', 'QFN32'). - `partName` (string|null): Optional part number / MPN to disambiguate package variants. Output parameters: - `bundle_status`: completed = both requested files were proven against this document. needs_review = a run finished (or a fallback file was attached) without that proof. cannot_extract = nothing usable. null = the pip… - `contract` (string): Contract schema identifier: kicad_evidence_v1 - `final_readiness`: The emit gate's full verdict. null when the pipeline never reached this stage. - `footprint_provenance`: Set only when this file did NOT come from this document's own extraction (a KiCad-library match or JEDEC/IPC-7351B math instead). null means the file was built from this document. - `human_warnings` (array) - `inputs` (object) - `kicad_sym` (string|null): Complete KiCad schematic symbol (.kicad_sym) file content, or null if withheld/not produced. - `manufacturer_part_number` (string|null): Resolved by the pipeline's identity resolution — not an echo of the input. See requested.part_name for what was sent. - `package_variant` (string|null): Resolved package code. - `requested` (object): Exactly what the caller sent, kept distinct from the resolved identity above. - `review` (object) - `status` (string): The pipeline's own run status. FAILED means nothing usable was produced and the credits for this call are refunded automatically. - `status_detail` (object) - `symbol_provenance`: Set only when this file did NOT come from this document's own extraction (a KiCad-library match or JEDEC/IPC-7351B math instead). null means the file was built from this document. - `warnings` (array): Engineering warnings emitted during generation ### `datasheetvend_extract_kicad_bundle` (~278 tokens) Extract complete KiCad CAD bundle Generate a KiCad footprint (.kicad_mod) and schematic symbol (.kicad_sym) from a datasheet in one call. Both files are loaded with kicad-cli where it is installed (a file-format check, not a DRC/ERC) and passed through the same deterministic copper, courtyard, pin-1 and pad-placement checks the dashboard uses. bundle_status "completed" means both files were independently proven against this document; "needs_review" means a file was produced (possibly from the KiCad library or JEDEC/IPC-7351B math instead of this document — see footprint_provenance/symbol_provenance) without that proof; "cannot_extract" means nothing usable was produced, and the credits for this call are refunded automatically (status FAILED). Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path works solely in local stdio mode (npm run mcp:serve).. - `packageSelection` (string|null): Optional package/variant (e.g. 'LQFP48', 'SOIC8', 'QFN32'). - `partName` (string|null): Optional part number / MPN to disambiguate package variants. Output parameters: - `bundle_status`: completed = both requested files were proven against this document. needs_review = a run finished (or a fallback file was attached) without that proof. cannot_extract = nothing usable. null = the pip… - `contract` (string): Contract schema identifier: kicad_evidence_v1 - `files` (object) - `final_readiness`: The emit gate's full verdict. null when the pipeline never reached this stage. - `footprint_provenance`: Set only when this file did NOT come from this document's own extraction (a KiCad-library match or JEDEC/IPC-7351B math instead). null means the file was built from this document. - `human_warnings` (array) - `inputs` (object) - `manufacturer_part_number` (string|null): Resolved by the pipeline's identity resolution — not an echo of the input. See requested.part_name for what was sent. - `package_variant` (string|null): Resolved package code. - `requested` (object): Exactly what the caller sent, kept distinct from the resolved identity above. - `review` (object) - `status` (string): The pipeline's own run status. FAILED means nothing usable was produced and the credits for this call are refunded automatically. - `status_detail` (object) - `symbol_provenance`: Set only when this file did NOT come from this document's own extraction (a KiCad-library match or JEDEC/IPC-7351B math instead). null means the file was built from this document. - `validation_report`: kicad-cli file-load result (sym/fp upgrade — a format check, not a DRC). - `warnings` (array): Engineering warnings ### `datasheetvend_extract_altium_bundle` (~201 tokens) Parse an Altium Designer ASCII footprint export Parse an Altium Designer ASCII footprint export (a text file — NOT a binary .PcbLib/.SchLib) and extract the footprint name, per-pad copper geometry (designator, name, coordinates, size, shape), layer map, and this module's own review/audit verdict. This reads an EXISTING Altium file; it does not build one from a datasheet PDF (for that, see the Altium Assist output pack on a completed extraction job). No model call — deterministic parsing only. Input parameters: - `documentPath` (string, required): https:// URL to an Altium ASCII footprint export (a text file, not a binary .PcbLib/.SchLib). The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them); a local filesystem path work… - `partName` (string|null): Optional component name / MPN. Output parameters: - `contract` (string): Contract schema identifier: altium_evidence_v1 - `delivery_status`: The module's own audit verdict for this file — the same one a REST/dashboard job would carry. - `footprint_name` (string|null): Extracted Altium footprint pattern name - `footprints_detected` (number): How many footprint blocks the file contained. Only one (the best match) is returned above. - `layer_map` (array) - `manufacturer_part_number` (string|null): The partName you sent, or the component name text found in the file — never the footprint's own name. - `other_footprint_names` (array): Names of the OTHER footprints in the file, not returned above — nothing is silently dropped. - `pads` (array) - `review` (object) - `source_format_detected` (string): line_block_ascii is the only format this tool actually reads. - `status` (string): FAILED means the credits for this call are refunded automatically: the file was unreadable, a recognized-but-unsupported format, or contained no footprint. - `units` (string): Coordinate/size units exactly as the source file stated them. Values are NEVER converted — 'unknown' means the file did not state a unit, not that the numbers are millimetres. - `warning_details` (array) - `warnings` (array): Engineering warnings emitted ### `datasheetvend_list_hardware_modules` (~65 tokens) List the hardware intelligence modules List all available hardware extraction modules supported by DatasheetVend (KiCad footprints/symbols, Universal Pinout, Thermal Limits, Absolute Maximum Ratings, Timing Characteristics, Logic Levels, Register Maps, Decoupling Passive BOM, Part Number Decoders, etc.). Output parameters: - `modules` (array) - `total_modules` (number): Total number of available hardware extraction modules ### `datasheetvend_list_component_twins` (~200 tokens) List your datasheets that have a component twin List the datasheets in your DatasheetVend account that have a Unified Component Model (UCM) digital twin: the facts DatasheetVend already extracted from each datasheet — pins, supply rails, interfaces, registers and whole-part limits — combined across the extraction runs stored for it. Returns each datasheet's exact name, the modules its twin draws on, how many runs it has and when it was last run. Reads stored results only: never extracts, never bills. Needs a DatasheetVend API key. Pass a returned name to datasheetvend_get_component_twin. To twin a datasheet the account has not extracted, use datasheetvend_build_component_twin. Input parameters: - `limit` (integer): How many datasheets to return, newest run first. Default 20. - `search` (string): Part of the datasheet's file name to filter by, case-insensitive (for example 'ATmega328P'). Output parameters: - `contract` (string): Contract id: ucm_twin_list_v1 - `datasheets` (array) - `next_step` (string) - `total` (number): Datasheets with a twin that match, before the limit ### `datasheetvend_get_component_twin` (~476 tokens) Read a datasheet's component twin Read the Unified Component Model (UCM) digital twin of one datasheet already extracted with DatasheetVend. Every fact comes with a check ('passed', 'needs_review', 'disagrees', 'failed_sanity_check') and, where the extraction recorded one, its datasheet page, filed where it belongs: pins, whole_part (temperatures, absolute limits, package, ordering code), interfaces_rails (I2C/SPI/clock/ADC requirements and supply-rail values), registers (the register map) and checks. Call it first with no options for the summary, then ask for `sections`, one `pin` (by number, name or alternate function) or a `search` term so the answer stays small. Treat facts that did not pass as unverified and cite their page. Reads stored results only: never extracts, never bills. Needs a DatasheetVend API key; find datasheet names with datasheetvend_list_component_twins. To twin a datasheet the account has not extracted, use datasheetvend_build_component_twin. Input parameters: - `datasheet` (string, required): The datasheet name exactly as datasheetvend_list_component_twins returns it. A unique part of the name also works. - `max_facts` (integer): Cap on facts returned across the pin and sections (default 200). `truncated` says when it was reached. - `only_passed` (boolean): Only facts that passed every check. Default false: every fact comes with its check. - `pin` (string): One pin by number, name or alternate function (for example '27', 'PC4' or 'SDA'): every fact that reaches it — its own and those of its rails and interfaces. - `search` (string): Only facts whose parameter, symbol, statement or node contains this text, case-insensitive (for example 'storage temperature' or 'TWCR'). With no sections given, searches pins, whole_part, interfaces… - `sections` (array): Parts of the twin to include besides the summary: pins (each pin's own facts), whole_part, interfaces_rails, registers, checks (disagreements, failed sanity checks, facts to review, facts that name n… Output parameters: - `built_from` (object) - `checks` (object) - `contract` (string): Contract id: ucm_twin_v1 - `counts` (object) - `datasheet` (string) - `how_to_read` (string) - `part` (object) - `pin`: The requested pin with the facts that reach it, or null when no pin was asked for. - `places` (object) - `sections` (object): The requested sections: pins, whole_part, interfaces_rails, registers, checks — facts with their check and, where recorded, their page. - `truncated` (boolean) - `warnings` (array) ### `datasheetvend_build_component_twin` (~690 tokens) Extract a datasheet into a component twin Extract a datasheet with DatasheetVend Fast Extraction and return its Unified Component Model (UCM) digital twin in one call. Fast Extraction runs once for every requested module, and the modules' facts combine into one twin, filed where they belong: pins, whole_part (temperatures, absolute limits, package, ordering code), interfaces_rails, registers and checks — every fact with a check ('passed', 'needs_review', 'disagrees', 'failed_sanity_check') and, where recorded, its datasheet page. Returns the same ucm_twin_v1 view as datasheetvend_get_component_twin, with every section unless you ask for sections, one pin or a search, plus an `extraction` block: the engine, `rescued_features` (modules Fast Extraction could not complete at turbo speed that the standard deep engine extracted instead, slower for just those modules -- still billed and still in the twin), the modules NEITHER engine could extract (no credits charged for those), the credits charged and stored=false. Treat facts that did not pass as unverified and cite their page. The twin is NOT saved to your account: datasheetvend_get_component_twin and the dashboard will not find it, and calling again extracts and bills again. Needs a DatasheetVend API key. Costs the requested modules' credits: pinout (1 credit), absolute_max (2 credits), pin_cautions (2 credits), logic_levels (2 credits), thermal (2 credits), timing (2 credits), register_map (3 credits), peripheral_matrix (2 credits), power_battery (1 credit), part_decoder (2 credits), cad_normalized (1 credit, extracted as footprint); all of them 20 credits. Input parameters: - `documentPath` (string, required): https:// URL to the datasheet PDF. The remote /api/mcp endpoint accepts ONLY https:// URLs (it downloads them). - `max_facts` (integer): Cap on facts returned across the pin and sections (default 200). `truncated` says when it was reached. - `modules` (array): Twin modules to extract and combine: pinout, absolute_max, pin_cautions, logic_levels, thermal, timing, register_map, peripheral_matrix, power_battery, part_decoder, cad_normalized. Omit for all of t… - `only_passed` (boolean): Only facts that passed every check. Default false: every fact comes with its check. - `partName` (string|null): Optional part number / MPN to target in a datasheet that covers several parts. - `pin` (string): One pin by number, name or alternate function (for example '27', 'PC4' or 'SDA'): every fact that reaches it — its own and those of its rails and interfaces. - `search` (string): Only facts whose parameter, symbol, statement or node contains this text, case-insensitive (for example 'storage temperature' or 'TWCR'). With no sections given, searches pins, whole_part, interfaces… - `sections` (array): Parts of the twin to include besides the summary: pins, whole_part, interfaces_rails, registers, checks. Omit, with no pin or search, for every section — this twin is not stored, so there is no secon… Output parameters: - `built_from` (object) - `checks` (object) - `contract` (string): Contract id: ucm_twin_v1 - `counts` (object) - `datasheet` (string) - `extraction` (object): The Fast Extraction run behind this twin - `how_to_read` (string) - `part` (object) - `pin`: The requested pin with the facts that reach it, or null when no pin was asked for. - `places` (object) - `sections` (object): The requested sections: pins, whole_part, interfaces_rails, registers, checks — facts with their check and, where recorded, their page. - `truncated` (boolean) - `warnings` (array) ## Diagnostics Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-datasheetvend-datasheet-contracts/api-mcp#diagnostics ## Score history - 2026-11-05: 76 - 2026-11-04: 75 - 2026-11-03: 75 - 2026-11-02: 74 - 2026-11-01: 74 - 2026-10-31: 73 - 2026-10-30: 73 - 2026-10-29: 72 - 2026-10-28: 73 - 2026-10-27: 72 ## Common questions ### What is the DatasheetVend MCP server? DatasheetVend is an MCP server listed in the public MCP registry as com.datasheetvend/datasheet-contracts. Turn datasheets into source-backed JSON contracts, pinout matrices, and KiCad CAD for AI agents. This page covers its hosted endpoint (https://datasheetvend.com/api/mcp). ### Is the DatasheetVend MCP server safe to use? DatasheetVend scores 76 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the DatasheetVend MCP server expose? DatasheetVend exposes 24 tools: datasheetvend_extract_document_map, datasheetvend_read_document_map_instructions, datasheetvend_inspect_document_page, datasheetvend_extract_pinout, datasheetvend_extract_thermal_limits, and 19 more. Their descriptions and schemas cost roughly 6,905 tokens of context every time the server is loaded. ### Does the DatasheetVend MCP server require authentication? No. We connected to DatasheetVend without credentials and it answered, so anything it exposes is reachable by anyone who knows the address. ### Is the DatasheetVend MCP server still maintained? DatasheetVend is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ## Links - Remote endpoint: https://datasheetvend.com/api/mcp - Repository: https://github.com/FelixNovaNexus/datasheet-vend - Website: https://datasheetvend.com/for-agents - Changelog RSS feed: https://verifymcp.io/servers/com-datasheetvend-datasheet-contracts/api-mcp.xml - Changelog JSON feed: https://verifymcp.io/servers/com-datasheetvend-datasheet-contracts/api-mcp.json - HTML version of this page: https://verifymcp.io/servers/com-datasheetvend-datasheet-contracts/api-mcp