protogrid

Search / com.datasheetvend/datasheet-contracts

DatasheetVend

R0· no sign-in

Turn datasheets into source-backed JSON contracts, pinout matrices, and KiCad CAD for AI agents.

v1.1.0 · active · repository · website · descriptor JSON · versions

An agent can connect right now, no human step.Remote endpoint, no authentication, reachable on the last probe.
Quality82good
Trust96of 100
Uptime, 30 days100%
Latency p50893 ms

Connect

8 clients · secrets stay placeholders
{
  "mcpServers": {
    "datasheet-contracts": {
      "type": "http",
      "url": "https://datasheetvend.com/api/mcp"
    }
  }
}
claude mcp add --transport http datasheet-contracts https://datasheetvend.com/api/mcp
[mcp_servers.datasheet-contracts]
url = "https://datasheetvend.com/api/mcp"
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "datasheet-contracts": {
      "type": "remote",
      "url": "https://datasheetvend.com/api/mcp",
      "enabled": true
    }
  }
}
{
  "mcpServers": {
    "datasheet-contracts": {
      "type": "http",
      "url": "https://datasheetvend.com/api/mcp"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=datasheet-contracts&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vZGF0YXNoZWV0dmVuZC5jb20vYXBpL21jcCJ9"
}
{
  "servers": {
    "datasheet-contracts": {
      "type": "http",
      "url": "https://datasheetvend.com/api/mcp"
    }
  }
}
{
  "mcpServers": {
    "datasheet-contracts": {
      "httpUrl": "https://datasheetvend.com/api/mcp"
    }
  }
}
extensions:
  "datasheet-contracts":
    enabled: true
    name: "datasheet-contracts"
    type: streamable_http
    uri: "https://datasheetvend.com/api/mcp"
    timeout: 300

Quality 82 / 100good

protocol75 · weight 25
  • warn
    protocol.modernnewest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
  • n/a
    protocol.statelessonly applies to 2026-07-28 servers
  • pass
    protocol.transportstreamable HTTP
  • n/a
    protocol.list_ttlonly applies to 2026-07-28 servers
authorizationn/a · weight 15
  • n/a
    auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
  • n/a
    auth.secret_in_urlno templated URL
tool hygiene88 · weight 30
  • pass
    tools.descriptionsevery tool has a description
  • warn
    tools.description_length9 tools have descriptions over 1,024 characters, which crowds the context
  • pass
    tools.schemasevery tool has an object input schema
  • pass
    tools.annotations24 of 24 tools declare readOnlyHint or destructiveHint
  • pass
    tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
  • warn
    tools.token_costabout 9,883 tokens to load every tool
  • pass
    tools.api_dumptools are not a one-to-one API dump
  • pass
    tools.hidden_textno hidden text in tool names, descriptions, schemas or annotations
stability83 · weight 15
  • warn
    stability.changes26 tool changes in 30 days
  • pass
    stability.rug_pullno tool changed its meaning under the same name
  • pass
    stability.new_linksno tool change named a new site
dependenciesn/a · weight 15
  • n/a
    deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

24 tools, about 9,883 tokens to load them all · tool set 62f3ca587dce · tools last changed 2026-11-12 · checked 2026-11-14 07:36 UTC

Tool changes

  • datasheetvend_extract_register_mapchangeddescription
    before

    Extract the register map: memory addresses, reset values, access permissions (RO/RW/W1C), and per-bit field definitions. canonical_output.value_checks labels each value by the check that reached it: verified means an outside source (OCR of the printed page, the vendor's register file) agreed; flagged values list both readings. No label claims a value is true of the chip. 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.

    after · 75% of words in common

    Extract the register map: memory addresses, reset values, access permissions (RO/RW/W1C), and per-bit field definitions. canonical_output.value_checks labels each value by the check that reached it: verified means an outside source (OCR of the printed page, the vendor's register file) agreed; flagged values list both readings. No label claims a value is true of the chip. canonical_output.svd_coverage says how many registers and bit fields device.svd holds and lists each one left out with a reason code. canonical_output.svd_readiness says whether device.svd may be loaded into a debugger: debugger_ready, description_only (a register description, not for live debugging; always so for an I2C/SPI device) or not_ready, with the first reasons; a check that did not run is never a pass, and debugger_ready does not mean every value is true of the chip. 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.

  • datasheetvend_extract_absolute_maxchangeddescription
    before

    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.

    after · 79% of words in common

    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. canonical_output.value_checks labels each delivered min, max and unit by the check that reached it: verified means OCR of the printed page agreed; flagged values list both readings. No label claims a value is true of the part. 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.

  • datasheetvend_extract_register_mapchangeddescription
    before

    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.

    after · 76% of words in common

    Extract the register map: memory addresses, reset values, access permissions (RO/RW/W1C), and per-bit field definitions. canonical_output.value_checks labels each value by the check that reached it: verified means an outside source (OCR of the printed page, the vendor's register file) agreed; flagged values list both readings. No label claims a value is true of the chip. 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.

  • datasheetvend_build_component_twinadded

    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.

  • datasheetvend_get_component_twinadded

    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.

  • datasheetvend_list_component_twinsadded

    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.

  • datasheetvend_extract_altium_bundleadded

    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.

  • datasheetvend_extract_kicad_bundleadded

    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).

  • datasheetvend_extract_kicad_symboladded

    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.

  • datasheetvend_extract_kicad_footprintadded

    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).

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 96 / 100

provenance85
liveness100
freshness100
hygiene100

+repository +dns-namespace +website +reachable +uptime-100% +updated-18d-ago

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remoteauthreachableuptime 30dp50protocollast ok
https://datasheetvend.com/api/mcp streamable-httpnoneyes100%893 ms2025-11-252026-11-14

Tools (24)

datasheetvend_build_component_twinread-onlyExtract 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.
datasheetvend_decode_part_numberread-onlyDecode 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.
datasheetvend_extract_absolute_maxread-onlyExtract 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. canonical_output.value_checks labels each delivered min, max and unit by the check that reached it: verified means OCR of the printed page agreed; flagged values list both readings. No label claims a value is true of the part. 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.
datasheetvend_extract_altium_bundleread-onlyParse 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.
datasheetvend_extract_analog_specsread-onlyExtract 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.
datasheetvend_extract_document_mapread-onlyBuild 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.
datasheetvend_extract_kicad_bundleread-onlyGenerate 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).
datasheetvend_extract_kicad_footprintread-onlyWrite 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).
datasheetvend_extract_kicad_symbolread-onlyWrite 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.
datasheetvend_extract_logic_levelsread-onlyExtract 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.
datasheetvend_extract_package_dimensionsread-onlyExtract 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.
datasheetvend_extract_passive_bomread-onlyExtract 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.
datasheetvend_extract_peripheral_matrixread-onlyExtract 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.
datasheetvend_extract_pin_cautionsread-onlyExtract 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.
datasheetvend_extract_pinoutread-onlyExtract 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.
datasheetvend_extract_power_domainsread-onlyExtract 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.
datasheetvend_extract_register_mapread-onlyExtract the register map: memory addresses, reset values, access permissions (RO/RW/W1C), and per-bit field definitions. canonical_output.value_checks labels each value by the check that reached it: verified means an outside source (OCR of the printed page, the vendor's register file) agreed; flagged values list both readings. No label claims a value is true of the chip. canonical_output.svd_coverage says how many registers and bit fields device.svd holds and lists each one left out with a reason code. canonical_output.svd_readiness says whether device.svd may be loaded into a debugger: debugger_ready, description_only (a register description, not for live debugging; always so for an I2C/SPI device) or not_ready, with the first reasons; a check that did not run is never a pass, and debugger_ready does not mean every value is true of the chip. 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.
datasheetvend_extract_thermal_limitsread-onlyExtract 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.
datasheetvend_extract_timing_characteristicsread-onlyExtract 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.
datasheetvend_get_component_twinread-onlyRead 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.
datasheetvend_inspect_document_pageread-onlyTier-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.
datasheetvend_list_component_twinsread-onlyList 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.
datasheetvend_list_hardware_modulesread-onlyList 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.).
datasheetvend_read_document_map_instructionsread-onlyReturn 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.

Schemas: list_tools.

Similar MCP servers

Official server.json
{
  "name": "com.datasheetvend/datasheet-contracts",
  "icons": [
    {
      "src": "https://datasheetvend.com/apple-touch-icon.png",
      "sizes": [
        "512x512"
      ],
      "mimeType": "image/png"
    }
  ],
  "title": "DatasheetVend",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://datasheetvend.com/api/mcp",
      "type": "streamable-http"
    }
  ],
  "version": "1.1.0",
  "repository": {
    "url": "https://github.com/FelixNovaNexus/datasheet-vend",
    "source": "github"
  },
  "websiteUrl": "https://datasheetvend.com/for-agents",
  "description": "Turn datasheets into source-backed JSON contracts, pinout matrices, and KiCad CAD for AI agents."
}