DatasheetVend
Server Details
Turn datasheets into source-backed JSON contracts, pinout matrices, and KiCad CAD for AI agents.
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 42 tools
Most tools have clearly distinct purposes, and the descriptions often explicitly say when to use one tool instead of another (for example extract_pinout vs extract_package_dimensions, or build_component_twin vs get_component_twin). Some clusters remain easy to confuse, especially document-map/inspect/read/search tools and decode_part_number vs resolve_part_number, but the guidance is unusually strong.
All tools use the datasheetvend_ prefix followed by snake_case verb_noun names, with only normal variation such as extract_*, get_*, list_*, search_* and check_*. The pattern is highly predictable across all 42 tools.
42 tools is far above the well-scoped 3-15 range and creates a heavy surface to navigate. Many tools are legitimate extraction modules, but the count is compounded by bundle tools that duplicate individual extract_* tools, so grouping or progressive disclosure would make the set more usable.
The surface covers the full lifecycle: library search, pre-extraction assessment, per-module extraction, document mapping, page inspection, evidence location, stored-result retrieval, diagnostics, design checks, KiCad/Altium generation, twins, and part packs. I see no major dead end for the stated datasheet-to-design workflow.
Available Tools
42 toolsdatasheetvend_assess_datasheetAssess a datasheet before extracting itARead-onlyIdempotentInspect
Judge whether a datasheet PDF is likely to extract well BEFORE you spend credits on it. Pass the public https URL of the PDF (datasheetvend_search_component_library returns one as datasheet_pdf_url). It reads up to 25 pages and checks structure deterministically: the text layer (scanned or image-only PDFs extract less reliably), page count, which standard datasheet sections are present (sectionsFound of sectionsChecked), and whether it is a family datasheet naming several packages. REPORT THE VERDICT AS GIVEN (likely_good, likely_partial, unlikely, unknown) and do not talk it up: hard gates only ever lower it. Read out the signals, and state the limitations: this is a structural assessment, never a promise that a module (pinout, thermal, footprint) will succeed. textTruncated and truncatedBy say when the read stopped early, so later sections were not seen. If the document cannot be fetched, say it could not be read; do not guess. Deterministic: no model, no extraction, nothing stored, costs no credits, needs a DatasheetVend API key.
Inputs: document_url (required).
datasheetvend_build_component_twinExtract a datasheet into a component twinARead-onlyInspect
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.
Inputs: documentPath (required), pin, search, modules, +4 more. Returns: pin, part, checks, counts, +9 more
datasheetvend_calculate_land_patternEstimate a land pattern (IPC-7351-style, generic)ARead-onlyIdempotentInspect
Estimate a land pattern from package numbers: a generic IPC-7351-style pad width, pad length and courtyard for a perimeter package (QFN/DFN/SON leadless, or QFP/SOIC/SSOP/TSSOP/SOP gull-wing). This is a nominal estimate, NOT IPC-7351B's tolerance-stacked tables, NOT IPC-certified and NOT the datasheet's recommended land pattern: use the datasheet's own drawing when it prints one. It gives one pad size for every pad, no pad positions, no numbered pad map and no exposed (thermal) pad, so it cannot build a footprint on its own; for an official KiCad footprint use datasheetvend_match_kicad_footprint. Each value's origin is in inputs_used (given, derived from a standard outline, estimated from pitch, or formula), and caveats travel with every result. An unsupported family or a missing input is refused and named. Free, no API key, no model call, reads no account data.
Inputs: pitch_mm (required), pin_count (required), package_type (required), body_width_mm (required), +6 more.
datasheetvend_check_design_valueCheck a design value against a datasheet's rulesARead-onlyIdempotentInspect
Check one design value against every rule DatasheetVend extracted from a datasheet (its pin-cautions rulebook): for example a 4.7 kΩ pull-up, a 100 nF decoupling capacitor or a 3.6 V supply. Returns pass, fail or needs_review per rule that applies, with the rule's datasheet source, and a summary that counts EVERY rule, including the ones that could not be compared, so 0 failures never hides 'nothing was compared'. An unknown unit is refused, not passed. Pass the job_id of an extraction in your account that ran the pin_cautions module. Deterministic: runs DatasheetVend's checks in code, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key.
Inputs: unit (required), value (required), job_id (required), package.
datasheetvend_check_parts_compatibilityCheck whether chips work together (draft wiring)ARead-onlyIdempotentInspect
Will these chips work together? Ask before you have a netlist. Reads ONLY the extraction jobs you pass (2-12, from your account; repeats are removed, and two runs of one part are one part), drafts a starting wiring from pin names the way the DatasheetVend Workbench does (one elected microcontroller wired to each device over I2C or SPI), runs the electrical rules on it and answers per pair. The answer rests on that DRAFT wiring, never on your schematic: basis is 'draft_wiring', and to audit a real board use datasheetvend_crosscheck_netlist. Never a bare 'yes': each pair is CONFLICT, NO CONFLICT FOUND (nothing the bench could check failed, not 'they work together') or NOT CHECKED, with checks_ran of checks_total and what is missing. Device-to-device pairs are never wired, so they stay NOT CHECKED; with no part proven a microcontroller nothing is wired at all; UART and CAN are never drafted. Read the pair counts (conflict_pairs, no_conflict_pairs, not_checked_pairs), verdict, rule_coverage and the assumed-value counts before you repeat an answer. Findings are capped, with their total. A job whose outputs are gone is refused. Deterministic: runs DatasheetVend's checks in code, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key.
Inputs: job_ids (required), protocol, system_voltage_v.
datasheetvend_compare_extractionsCompare one module across extractionsARead-onlyIdempotentInspect
Compare the SAME module across 2-4 of your extraction jobs in one aligned table, instead of reading each job. Rows align on key_field (default: the pin or register identifier) and compare value_field (default: the name); pass keys for specific pins or registers. Parts are never merged: values are positional per job, and a key missing from one part is null there. A job whose outputs expired, whose module is empty or unreadable is listed with its problem, never dropped. Differences come first and differingRows counts every row, not only the returned page (totalRows beside it). Get job ids from datasheetvend_search_my_extractions. Reads the recorded state of your account's own jobs (owner, or TEAM-shared in your workspace; a refunded job is refused): nothing is extracted and no model is called. Costs no credits. Needs a DatasheetVend API key.
Inputs: module (required), job_ids (required), keys, limit, +2 more.
datasheetvend_crosscheck_netlistAudit a KiCad netlist against extracted datasheetsARead-onlyIdempotentInspect
Audit a KiCad netlist against the datasheets your account has extracted with DatasheetVend. Compares symbol names with the datasheet, checks every pin exists, supply and ground pins sit on rails of the right kind and voltage, NC pins are left open, pin functions agree across each net, and pull-ups and the electrical rules that have data to run. verdict says how many pins were really compared and rule_coverage which rules could not run; a part with no matching extraction is reported as unmapped, never guessed. Deterministic: runs DatasheetVend's checks in code, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key.
Inputs: job_ids (required), netlist (required), system_voltage_v.
datasheetvend_decode_part_numberDecode manufacturer ordering part numbersARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_diagnose_extractionDiagnose what happened to an extractionARead-onlyIdempotentInspect
Explain what happened to an extraction, module by module, from recorded state. Keep the outcomes apart: never_requested (not asked for, not a failure), nothing_found (ran; the datasheet does not document it), needs_review, still_running and failed (a recorded error). When failureReason is present, lead with whose problem it is (our_infrastructure means re-running is worth it). Quote the recorded reason, never invent one; if unexplained is true, say nothing was recorded. Recorded error messages longer than 500 characters are cut (errorMessagesCut). Reads the recorded state of your account's own jobs (owner, or TEAM-shared in your workspace; a refunded job is refused): nothing is extracted and no model is called. Costs no credits. Needs a DatasheetVend API key.
Inputs: job_id (required).
datasheetvend_estimate_power_budgetEstimate supply current and battery lifeARead-onlyIdempotentInspect
Estimate a system's supply current and battery life (not thermal power dissipation) from parts your account extracted: total active current (mA), total standby current (uA), a breakdown per part and battery life on six standard batteries, as the DatasheetVend Workbench POWER tab computes it. Reads ONLY the jobs you pass: include each part's power_battery run, and its pinout run (it sets the role a fallback figure rests on). Active is the highest stated active row, standby the deepest stated low-power row (a best case), typical where stated and max otherwise. A part with no stated current gets a generic figure for its role, flagged is_estimated, and the totals then include estimates: read coverage (chips_active_stated of chips_on_bench, chips_standby_stated) before you repeat a number. Battery life assumes 5% active / 95% standby, nominal capacity, no derating or self-discharge. system_voltage_v is echoed, never used to rescale a current. A job whose outputs are gone is refused. Deterministic: runs DatasheetVend's checks in code, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key.
Inputs: job_ids (required), system_voltage_v.
datasheetvend_explain_warningsExplain an extraction's warningsARead-onlyIdempotentInspect
Report the warnings an extraction raised, grouped and ranked by DatasheetVend's own classifier (the grouper the result page's warnings panel uses). Use it before trusting an extraction. Report BOTH counts: issues (distinct problems) and findings (occurrences). Use the severity given (critical, review, info); an info group or one marked internal is a pipeline note, not a problem with the part, and highSignal groups (contradictions, incompleteness) go first. severityBasis says what the severity rests on. Zero warnings is a complete answer. At most 20 groups are listed; groupsTotal says how many exist. Reads the recorded state of your account's own jobs (owner, or TEAM-shared in your workspace; a refunded job is refused): nothing is extracted and no model is called. Costs no credits. Needs a DatasheetVend API key.
Inputs: job_id (required).
datasheetvend_extract_absolute_maxExtract absolute maximum ratingsARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_altium_bundleParse an Altium Designer ASCII footprint exportARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: pads, units, review, status, +10 more
datasheetvend_extract_analog_specsExtract analog domain specifications (ADC/DAC, Op-Amps, VREF)ARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_document_mapMap a datasheet (deterministic index)ARead-onlyIdempotentInspect
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.
Inputs: documentPath (required). Returns: map, cached, review, documentRef, +1 more
datasheetvend_extract_kicad_bundleExtract complete KiCad CAD bundleARead-onlyIdempotentInspect
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).
Inputs: documentPath (required), partName, packageSelection. Returns: files, inputs, review, status, +12 more
datasheetvend_extract_kicad_footprintExtract KiCad PCB footprint (.kicad_mod)ARead-onlyIdempotentInspect
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).
Inputs: documentPath (required), partName, packageSelection. Returns: inputs, review, status, contract, +12 more
datasheetvend_extract_kicad_symbolExtract KiCad schematic symbol (.kicad_sym)ARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName, packageSelection. Returns: inputs, review, status, contract, +11 more
datasheetvend_extract_logic_levelsExtract DC logic levels and operating conditionsARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_package_dimensionsExtract package dimensions and land geometryARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_passive_bomExtract passive support BOMARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_peripheral_matrixExtract on-chip peripheral matrixARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_pin_cautionsExtract pin cautions and design rulesARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_pinoutExtract datasheet pinoutARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName, packageSelection. Returns: engine, review, evidence, documentRef, +2 more
datasheetvend_extract_power_domainsExtract power domains and consumptionARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_register_mapExtract hardware register mapARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_thermal_limitsExtract thermal resistance and operating limitsARead-onlyIdempotentInspect
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. A thermal resistance value the table reader could not prove complete or correctly placed carries review_required: true and a review_reason saying what to check in the PDF; the warnings name the same values. 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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_extract_timing_characteristicsExtract AC timing characteristicsARead-onlyIdempotentInspect
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.
Inputs: documentPath (required), partName. Returns: engine, review, status, contract, +5 more
datasheetvend_get_component_twinRead a datasheet's component twinARead-onlyIdempotentInspect
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.
Inputs: datasheet (required), pin, search, sections, +2 more. Returns: pin, part, checks, counts, +8 more
datasheetvend_get_part_packBuy a part packAInspect
Buy one part pack: a component's frozen module outputs (pinout, footprint, limits, timing and the others the manifest lists) as one JSON envelope. Price: 3 module credits with a DatasheetVend API key, charged once per account (the same pack again is free), or $2.00 per call with a Stripe machine payment (no account, so each call pays). The pack is found before anything is charged: a missing pack, an unnamed package when several are shelved, or a pack too large for one answer costs nothing. Read the free manifest first: a pack may cover only some modules. The manufacturer's PDF is linked, never included. This is not the $19 Verified Pack sold on the website.
Inputs: part_number (required), vendor_slug (required), package.
datasheetvend_get_part_pack_manifestSee a part's shelved packsARead-onlyIdempotentInspect
See what DatasheetVend has shelved for a part BEFORE buying: each package variant's part pack, with the modules it holds and the ones it does not (module_count_available of module_count_total), its warnings, the source jobs and the manufacturer datasheet link. A missing part answers 'no shelved pack'. Free, no API key, no model call. Buy a pack with datasheetvend_get_part_pack.
Inputs: part_number (required), vendor_slug (required).
datasheetvend_inspect_document_pageInspect one mapped page (Tier-2 detail)ARead-onlyIdempotentInspect
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.
Inputs: page (required), documentRef (required), include_physical. Returns: page, cached, status, inspection, +1 more
datasheetvend_list_component_twinsList your datasheets that have a component twinARead-onlyIdempotentInspect
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.
Inputs: limit, search. Returns: total, contract, next_step, datasheets
datasheetvend_list_hardware_modulesList the hardware intelligence modulesARead-onlyIdempotentInspect
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.).
Inputs: no named parameters. Returns: modules, total_modules
datasheetvend_locate_evidenceLocate an extraction's values on its source pagesARead-onlyIdempotentInspect
For every extracted value of an extraction job (one module, or all of them), find the exact words on the source datasheet page the extraction cites and return their box: x, y, width, height normalized 0-1 to the page (origin top-left) plus bounds_pt in PDF points. Each value gets exactly one status: located (its own words boxed, inside or beside the cited snippet), located_value_only (its words occur once on the page and are boxed, but the cited snippet is not on the page), located_snippet_only (the cited snippet boxed, value text not inside it), ambiguous (found more than once, no box guessed), not_found, no_text_layer (a scan), page_unavailable, map_unavailable / map_expired (no document map), no_evidence_page (the output gives no page) or no_value_to_find (the output states no value text and no snippet). box_scope says how tight a box is: 'value' (exactly the value's characters), 'value_estimated' (the value sits inside a longer printed label; its box is estimated from its character offsets, the whole label is in container_boxes), 'label' (could not be narrowed, e.g. vertical text: the whole label is boxed) or 'snippet' (the cited snippet, not the value). matched_text is the text inside the boxes. coverage counts the statuses for the window returned and adds up to targets_returned; page through targets_total with offset / next_offset. Modules without per-value page evidence (kicad, altium and other generated outputs) are listed as not_applicable with the reason. Deterministic: reads the stored output and document map, calls no model. Costs no credits. Needs a DatasheetVend API key; readable jobs are your own, your workspace's TEAM-shared jobs and PUBLIC jobs, as on the REST API.
Inputs: job_id (required), limit, module, offset.
datasheetvend_match_kicad_footprintMatch chips to official KiCad footprintsARead-onlyIdempotentInspect
Find the official KiCad library footprint for chips from their package numbers. An id comes back only when pin count, pitch and body size agree on source evidence and exactly one official footprint fits; otherwise the status is 'ambiguous' (with the candidates and what separates them) or 'unresolved' (with the reason), and footprint_id is null, because a wrong footprint on a board is worse than none. choices records an engineer's pick among the candidates of an ambiguous chip; a pick that is not a candidate is ignored and listed with its reason. Numbers in, library ids out: no job data is read. Deterministic: runs DatasheetVend's checks in code, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key.
Inputs: chips (required), choices.
datasheetvend_read_document_map_instructionsDocument Map usage instructionsARead-onlyIdempotentInspect
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.
Inputs: no named parameters. Returns: instructions
datasheetvend_read_document_pageRead one page of an extraction's source datasheetARead-onlyIdempotentInspect
Read one page of the source datasheet behind an extraction job as positioned text tokens (text and box in PDF points), in reading windows of at most 1500 tokens (token_offset / next_token_offset). Carries the page's census: text_token_count, vector_path_count, raster_image_count. textless=true means no positioned text (a drawing, a scan, or an old map), not a blank page; payload_elided=true means the page's tokens were dropped to fit the document budget, so read text_token_count. Drawings and images are not served here. Pages are the PDF's physical 1-based pages. Deterministic: reads the stored document map, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key; readable jobs are your own, your workspace's TEAM-shared jobs and PUBLIC jobs, as on the REST API.
Inputs: page (required), job_id (required), token_limit, token_offset.
datasheetvend_resolve_part_numberResolve a part number against a datasheet's own legendARead-onlyIdempotentInspect
Resolve a full ordering code against a datasheet your account already extracted with the part_decoder module: the document's own part-number legend and ordering table, as that run read them. Returns the status verbatim, each parsed position with its meaning, page and snippet, any unexplained characters, the ordering-table match and the merged package and temperature facts. The meaning is the document's own legend: fully_decoded is NOT 'orderable' (every character is explained but the code is not in the ordering table), ambiguous lists every reading and picks none, and a family legend can define codes for sibling parts. State a code as the part's identity only when answer.may_assert_identity is true. A run with no part-number grammar is refused (NO_UNIVERSAL_BLOCK), never guessed. No new extraction. Deterministic: runs DatasheetVend's checks in code, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key.
Inputs: job_id (required), part_number (required).
datasheetvend_search_component_librarySearch the component libraryARead-onlyIdempotentInspect
Search DatasheetVend's component library: parts from dozens of manufacturers whose manufacturer datasheet DatasheetVend stores. Search by part number, vendor, package, architecture or application words (for example 'STM32 QFN', 'ESP32', 'BLE wearable', 'Cortex-M4'), optionally filtered by vendor, package family, category, pin range or Verified Pack. Each result gives the part page, the stored datasheet PDF (often a family datasheet covering several ordering codes), the manufacturer's own URL when known, whether a curated Verified Pack exists, and the address of the part-pack manifest (a lookup that may answer 'no shelved pack'). A result is a stored datasheet, not extracted data: to extract it, pass its datasheet_pdf_url to an extraction tool. Any one search word can match a row; results are ranked, paged with offset, and do not report a total. Free, no API key, no model call.
Inputs: query (required), limit, offset, vendor, +4 more.
datasheetvend_search_documentSearch the source datasheet of an extractionARead-onlyIdempotentInspect
Find where the source datasheet behind an extraction job says something: every text token containing the term, with its page and its box on the page in PDF points. Use it to check an extracted value against the document, or to find the page to read with datasheetvend_read_document_page. Counts are honest: total_hits with hits_returned, a per-page cap of 20 stated with dropped_hits, and fetch_truncated when the database fetch stopped at its cap. A token is one line of text, so a phrase across lines may not match. Three different refusals: DOCUMENT_MAP_UNAVAILABLE (this job has no document map), DOCUMENT_MAP_EXPIRED (the map passed its retention window: no hits does NOT mean the term is absent) and, for a real answer, zero hits. Deterministic: reads the stored document map, calls no model and extracts nothing. Costs no credits. Needs a DatasheetVend API key; readable jobs are your own, your workspace's TEAM-shared jobs and PUBLIC jobs, as on the REST API.
Inputs: query (required), job_id (required), max_hits.
datasheetvend_search_my_extractionsSearch your extractionsARead-onlyIdempotentInspect
Find your own (non-archived) extraction jobs by condition: filename words, a module that produced output, jobs with warnings, or jobs waiting on a decision. Returns job ids, status, warning counts and which modules hold output, never module data: pass an id to the other tools (datasheetvend_explain_warnings, datasheetvend_compare_extractions, datasheetvend_search_document) or read GET /api/v1/jobs/{id}/. totalMatched is counted after every filter: exact when scanComplete is true, otherwise a stated floor over the newest jobs scanned (countingNote). An empty list is a real answer. Reads the recorded state of your account's own jobs (owner, or TEAM-shared in your workspace; a refunded job is refused): nothing is extracted and no model is called. Costs no credits. Needs a DatasheetVend API key.
Inputs: limit, module, filename_contains, only_with_warnings, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
Electronic component datasheets for AI agents: pinouts, specs, package info and design checks.
Design, route, check, review and export manufacturable PCBs from plain language; KiCad import.
Design circuits, simulate and verify embedded firmware, and lay out PCBs with AI agents.
Verified KiCad footprints, symbols & 3D models for AI agents. No signup, CC-BY-4.0, quality-gated.
Related MCP Servers
- AlicenseAqualityBmaintenanceProvides AI agents with instant, structured access to electronic component datasheets, pinouts, and electrical specifications without requiring PDF uploads. It enables seamless part searching, design validation, and side-by-side component comparisons across major hardware providers.1495 npm12MIT
- AlicenseBqualityBmaintenancedatasheet-lens gives the content of component datasheets (PDF) to an LLM agent, for electronics design (KiCad and other CAD tools) and firmware work.34629 PyPIMIT
- AlicenseAqualityCmaintenanceEnables AI assistants to search millions of electronic components and ICs, retrieve specifications, compare alternates, and submit turnkey BOM procurement requests.4MIT
- FlicenseDqualityBmaintenanceEnables AI agents to design electrical schematics through a high-level semantic API, handling components, pins, nets, validation/ERC, auto-layout, and SVG/KiCad rendering without requiring coordinate or file internals.22-
Glama MCP Gateway
Add one secure layer between your agents and this server.