DatasheetVend MCP Server

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.

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.

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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.