Alpha First public release: 0.1

Hardware design with an AI agent · Open source

Describe the board. Your agent designs it from the datasheets.

SheetDiver gives your agent a datasheet library it can search, fill and design from. Ask for a board and it finds the parts in a catalogue of 2.5 million, imports their datasheets, extracts the limits, builds the project with its rails and loads, drafts the reference schematic, and checks every rail against every datasheet. You watch each step on your screen, and every value it verified stays in the library.

Download SheetDiver Connect your agent

Works with Claude Code, Cursor, VS Code, Claude Desktop, Codex — anything that speaks MCP. macOS, Windows and Linux. Everything stays on your machine.

Latest release: v0.1.1

A reference schematic drawn by SheetDiver from the connection table an agent drafted: the PCM5102A DAC as a symbol with numbered pins, its decoupling capacitors beside it under the rail's name, the charge-pump capacitors across their pins, net labels on the signal pins, and the reset and boot buttons in their own frames.
The reference schematic of a DAC board the agent drafted, drawn from the connection table and checked against every pin table.

Design with an agent

From a sentence to a checked reference design

Your agent works in your terminal or editor; SheetDiver is the library it designs from and the screen you watch it on. One request runs the whole chain, and you can stop it at any step.

  1. 1

    Find the parts

    It searches the JLCPCB catalogue by specs, in stock, basic library first: a 3.3 V buck-boost for 400 mA, an I2S DAC with line out, a USB-C receptacle. Catalogue →

  2. 2

    Import the datasheets

    Each candidate's datasheet comes into the library and is extracted: parameters with min/typ/max, every graph, the pin table, the recommended inductors and capacitors. Library →

  3. 3

    Verify the values

    It reads the electrical characteristics and the graphs as images, corrects what extraction got wrong, and records what it checked, so the next design starts from the verified numbers.

  4. 4

    Build the project

    Rails with their voltages, the BOM with designators and roles, each part's supply and load. The loads add up through the regulators. Boards →

  5. 5

    Draft the schematic

    Pins on nets, passives where they serve, functional groups. SheetDiver draws it as a schematic and checks every connection against the pin tables.

  6. 6

    Check it against every datasheet

    Every rail against every part's absolute-maximum and recommended limits, the regulators' ratings, open pins that must be connected; then the calculators and a design review you can hand to a colleague.

What that looks like

You

Design a USB-C powered audio board: ESP32-C6 as the I2S master, a stereo DAC with a 3.5 mm line out, 3.3 V from a buck-boost. JLCPCB basic parts where you can.

Claude Code
  • search_catalog→ DC-DC, VIN ≥ 4.4 V, IOUT ≥ 400 mA, in stock · 38 parts
  • search_catalog→ audio DAC, I2S, line out · 6 parts
  • import_datasheets→ MAX77827, PCM5102A, ESP32-C6-MINI-1, USBLC6-2SC6, TYPE-C-31-M-12
  • get_parameters→ PCM5102A · DVDD 1.65 … 1.95 V (p6)
  • create_project · set_rail · add_to_project→ C6 Audio DAC · VBUS, 3V3, 3V3A · 18 BOM lines
  • set_connections→ 143 connections, 5 groups · drawn
  • get_project→ 2 errors, 5 warnings

The board is in the project C6 Audio DAC, with the schematic drafted. The checks caught one thing I'd have missed: the PCM5102A's digital supply tops out at 1.95 V, so DVDD has to come from its internal LDO output, not 3V3. I've opened a walkthrough of the fix.

You

Size the input and output caps for the buck-boost too.

Claude Code
  • calculatebuck · MAX77827 · fsw 2.5 MHz from p7

4.7 µH, 170 nF minimum output capacitance at 1% ripple; the calculator is on your screen with the page behind each number, saved to the project.

The board project the agent built: three rails with their loads and the one that fails its check, the agent's explanation in a panel on the right, and a walkthrough bar at the bottom, step 1 of 3.
What you see: the project the agent built, its explanation beside it, and a walkthrough of the problem you step through with Next.

Why a library, and not just a smarter chat?

01

Agents read PDFs as text soup

A spec table flattened to text loses which column was typ and which condition it was measured under. SheetDiver extracts the table once, with its page, and the agent reads rows.

02

The checks need numbers, not prose

Does 3V3 stay under the DAC's absolute maximum? What does the regulator's input really draw? With the limits as data, every board is checked the same way, automatically.

03

What it learns should stay learned

A value the agent corrected, a graph it described, an inductor it picked: recorded in the library, marked as its own, kept for the next board and the next session.

SheetDiver makes the datasheet a database you both use: extracted once with page references, checked against your board, and corrected by whoever reads it, you or the agent.

Library

Everything in the datasheet, in its place

Import a PDF, or just type TPS563200, and the datasheet becomes rows and figures you can search, sort, compare and correct.

  • Parameters as min/typ/max with conditions, section (absolute maximum, recommended, electrical), page, and a canonical key: vin, iout, fsw, ilim, iq, rdson, qg… Edit any cell; your values win and survive re-extraction.
  • Every captioned figure cut out and classified: graph, schematic, waveform, block diagram, pinout, timing, layout, package, with axes read from "Y vs X" captions. Describe what a graph shows and it becomes searchable.
  • Pins, sections and registers: the pin table per package, the full section tree with its text, and register maps the agent records.
  • Part numbers that resolve: TPS563200DDCR, MCP1700T-3302E/TT, STM32U545VET6Q and TPS56x200 all find the right part. Revisions are detected, and a newer one updates in place.
The Figures tab of a part: 62 figures as a gallery, filtered by kind (waveform, graph, schematic, block diagram, pinout), each with its number, kind and page.
62 figures from one datasheet, each cut out, classified and placed on its page.
The page viewer on page 7 of a datasheet: three graphs outlined with their figure numbers, thumbnails of the pages on the left.
The page viewer: figures and tables outlined where they were found, the exact region of any parameter highlighted on click, and drag-to-select to read a region or define a missed figure.
A figure view: a quiescent-current-versus-input-voltage graph cut out of the datasheet, with a form beside it for its kind, title, axes, conditions, description and curves.
A graph on its own, with what it shows recorded beside it. Agents see the same image and fill the form in after looking.

Compare, and find what could replace a part

Pick a component type and see its parts side by side on the parameters that matter for it, sorted and filtered with units ("VIN ≥ 24 V, IOUT ≥ 3 A, IQ ≤ 1 µA"), every value linked to its page. Ask what else in your library could replace a part, and the alternatives are ranked key by key: ▲ better, = same, ▼ worse, drop-ins first.

Star parts and mark them preferred, approved, avoid, NRND or EOL. Projects warn about the bad ones, and agents are told to prefer the good ones.

Two buck-boost converters compared parameter by parameter, with the best and worst values marked and a note from the agent under each part.
A comparison the agent put on screen, with its note under each part and the best and worst values marked.

Boards

Your board, checked against every datasheet

A project is a board: its BOM with designators, its rails and their currents. SheetDiver does the power arithmetic and the limit checks you'd otherwise do by hand, with the page reference on every finding.

  • Loads add up through the regulators: a rail's load, the regulator's input current derived from it, and the input power at full load. Chargers, load switches and protection ICs count the way they really draw.
  • Checked against the datasheets: every rail against every part's absolute-maximum and recommended limits, regulator ratings, parts without a datasheet, parts marked avoid, and the ripple each rail can carry before a part leaves its range.
  • BOM import from CSV, KiCad, Altium or LCSC codes: parts found in the library or fetched by part number.
  • A design review as Markdown in one click: findings, rails, parts with their key parameters, the block diagram, connections and calculations.
A board project: three rails with their voltage range, source, load against the regulator's rating and power, one rail in red because a part on it has no ripple budget left; two errors and five warnings in the header.
Three rails, their loads against what feeds them, and the one that's in trouble: the DAC's input maximum is below 3V3.

A schematic from the connection table

Put pins on nets, or have your agent draft them, and the board is drawn as a schematic: each part as a symbol generated from its pin table, passives with their values as standard symbols, ground symbols and power ports, net labels on the pins, functional groups in their own frames. The connection table is checked against the pin tables: pins that don't exist, supply or ground pins on the wrong net, pins that must be connected and aren't. Zoom, drag, export as SVG.

Drawn from the data, not drawn by hand: change a connection and the drawing follows.

The block diagram of a board, zoomed on the DAC: the PCM5102A as a symbol with numbered pins, decoupling capacitors beside it under the rail's name, the charge-pump capacitors across their pins, and net labels on the signal pins.
The DAC section of the board: the part's symbol from its pin table, its capacitors where they belong, and every pin named.

Calculators filled from the datasheet

Buck, boost, LDO, MOSFET gate drive, gate divider and resistor divider. Leave a field empty and it's taken from the datasheet or the project's rails, with the page it came from; the outputs come with their formulas, the checks (minimum on-time, current limit, thermal) and suggestions. Save the result to the project.

The buck calculator: input fields with units on the left, and on the right the result line and cards for duty cycle, inductance, ripple and peak current, saturation rating, output capacitance and ESR, input capacitance, each with its formula.
A buck design for the board's 3V3 rail: inductor, ripple, peak current, output capacitance and the input capacitor, each with the formula behind it.

Catalogue

2.5 million parts, searched offline

One click downloads JLCPCB's catalogue (the open jlcparts dataset, refreshed three times a day) so you can search it without a browser tab per vendor.

  • By specs, not by name: browse a category and filter on its own parameters, VDS ≥ 30 V, RDS(on) ≤ 10 mΩ, package SOT-23, in stock. Each filter's values follow the others, with counts.
  • Stock, price and library for every part, basic or extended, and a link to LCSC or JLCPCB.
  • Tick the parts you want and their datasheets are imported into the library. Part-number lookups and BOM imports fall back to the catalogue's datasheet links.
The parts catalogue: a search for 3.3 V buck converters in stock, the category tree with part counts on the left, and the matching parts with their LCSC code, manufacturer, description and package.
Buck converters for 3.3 V, in stock: tick the ones worth a look and their datasheets join the library.

Get started

Up and running in three steps

  1. 1

    Import a datasheet

    Drop a PDF on the window, or type a part number. Extraction runs locally in a sandboxed PDF engine; nothing is uploaded.

    sheetdiver import tps563200
  2. 2

    Connect your agent

    One command adds SheetDiver as an MCP server. Your agent can now read the library, look at the graphs, and record what it checks.

    claude mcp add --transport http --scope user sheetdiver http://127.0.0.1:47480/mcp
  3. 3

    Ask

    "Check the extracted parameters against the electrical characteristics." "Design a 12 V to 3.3 V, 2 A supply with it." "Put my sensor board in a project and check every rail." With Follow agent on, what it shows opens in front of you.

Connect

Works with the agent you already use

SheetDiver runs a local MCP server with 48 tools for reading the library, recording what the agent verifies, importing, projects and calculators. Add it to your agent with one line.

Connect in one line

The server listens at http://127.0.0.1:47480/mcp. Stdio-only clients use the built-in bridge, sheetdiver mcp; Claude Desktop gets a one-click extension from the app's MCP pill.

claude mcp add --transport http --scope user sheetdiver http://127.0.0.1:47480/mcp
The Connect an agent dialog: the server's address and status, and tabs for Claude Code, Claude Desktop, Codex, Cursor, VS Code, Gemini CLI and Windsurf with the command or config file for each, ready to copy or save.
The MCP pill opens this: every client's setup with this copy's path filled in, and each config file saved on request.
See all 48 tools

Read the library

Structured answers with page references, not guesses from a PDF.

  • library_overview · search · list_categories · list_parts
  • get_part · get_parameters key parameters, min/typ/max with conditions and pages
  • get_section · read_pages · get_page_image the text, or the page as an image
  • list_figures · get_figure · get_tables graphs, schematics and tables as images
  • get_pins · get_registers · compare_parts · find_alternatives
  • get_ui_context what you have open right now

Record what it learns

Marked as the agent's, kept across sessions, winning over extraction.

  • record_parameters corrected or missing spec rows
  • describe_figure what a graph shows, with values read off it
  • record_table · record_pins · record_registers transcribed from the images
  • record_recommendations the inductors and capacitors the datasheet asks for
  • update_part · add_note · list_notes

Show you

Put it on your screen instead of in the chat.

  • show a part, page, figure, section, project, comparison, catalogue search or calculator, with a caption
  • show_walkthrough several of those in order, stepped through with Next

With Follow agent on, each one opens in front of you.

Import and the catalogue

Only when you let it: agent imports can be switched off.

  • import_datasheet · import_datasheets by file, URL or part number
  • import_bom a CSV or KiCad BOM into a project
  • check_datasheet_updates · apply_datasheet_update newer revisions
  • catalog_parameters · search_catalog 2.5 million parts by specs

Boards and calculators

The same projects and checks you see in the app.

  • list_projects · create_project · get_project · delete_project
  • set_rail · add_to_project · update_project_part rails, BOM lines and currents
  • set_connections · get_connections · get_diagram_image the schematic, drafted and checked
  • export_project_report the design review as Markdown
  • list_calculators · calculate buck, boost, LDO, gate drive, dividers

Agents can't delete datasheets from the library.

Safety model

Your library, your rules

  • 01
    Local only. The server binds to 127.0.0.1, rejects DNS rebinding and cross-site requests. Your datasheets and designs never leave your machine.
  • 02
    Sandboxed PDFs. Datasheets are parsed by PDFium compiled to WebAssembly, with no filesystem access inside the engine.
  • 03
    Agents are marked. Everything an agent records is tagged as its own and stays inside the library. Settings turn agents off, make them read-only, or forbid imports.
  • 04
    No deletion by agents. Removing a datasheet is yours to confirm, with a list of what goes.
  • 05
    Online only when you ask. Importing from a URL or part number, checking for a newer revision, downloading the catalogue, or fetching the offline translation model, each on request.

What extraction handles

Deterministic

No model, no network

Outlines and headings, two-column pages, side-by-side graphs, spec and pin tables in the TI, ST, Microchip, Infineon and AOS styles, revisions, recommended components. Checked against a corpus of real datasheets, with exact page references so you can confirm anything.

Included

Chinese and small-vendor datasheets

Chinese headings, spec and pin tables, uncaptioned figures and pins described in prose. A part's text can be translated to English inside the app, offline, with an electronics glossary; the model downloads only when you ask.

The limits

Where it needs help

Dense multi-column tables in large MCU datasheets and scanned PDFs extract poorly. The section text and page images are still there for you and the agent to read, and anything recorded takes precedence over extraction.

How extraction works, and what it's checked against →

Releases

What's new

Every release is built and tested in CI on macOS, Windows and Linux, with checksums, an SBOM and signed build provenance for every download.

v0.1.1

Latest October 24, 2026

The first public release: the desktop app, its built-in MCP server, the parts catalogue, and installers for every platform.

  • Datasheets in, structured data out: parameters, figures, pins, registers and sections with page references
  • Board projects with rails, loads, limit checks, a schematic from the connection table, and design calculators
  • The JLCPCB parts catalogue, searched offline by specs
  • 48 MCP tools and a Claude Desktop extension
All downloads

All releases on GitHub · Changelog · RSS feed

Get SheetDiver

Free and open source under the MIT license. An alpha: expect rough edges, and tell us about them.

macOS & Linux

curl -fsSL https://raw.githubusercontent.com/aitakemyjob/sheetdiver/main/scripts/install.sh | sh

Universal app for Apple Silicon & Intel. Linux: .deb, .rpm, .tar.gz (x64, ARM64); needs WebKitGTK 4.1.

Windows

irm https://raw.githubusercontent.com/aitakemyjob/sheetdiver/main/scripts/install.ps1 | iex

Installer or portable .zip. Uses the WebView2 runtime built into Windows.

Server / headless

sheetdiver serve

The same UI in your browser, and the same MCP server, on a box without a desktop. Binaries for every OS and architecture.

The builds aren't code-signed yet. The install scripts verify each download's checksum; by hand, check checksums.txt, then clear the quarantine flag on macOS or choose More info › Run anyway on Windows.

All downloads Star on GitHub