---
name: adom-mouser
description: Search Mouser Electronics for components, pricing, stock, and part numbers. Use when the user asks to find components on Mouser, check Mouser pricing, look up a Mouser part number, search for in-stock parts, get price breaks, compare alternatives, or find a datasheet or product page for a specific part. Also use for "open mouser", "mouser app", "mouser search UI".
---

# Mouser Electronics Search

Search Mouser's catalog of millions of electronic components from thousands of manufacturers. Real-time pricing, stock, lead times, and product links.

## What you have

A single CLI — `adom-mouser` — with three faces:

1. **One-shot search from the shell**, for when the AI just needs the data:
   ```bash
   adom-mouser search "STM32F103RBT6"
   adom-mouser part 511-STM32F103RBT6
   adom-mouser health
   ```
   Each prints JSON on stdout and an `OK:` / `ERROR:` line on stderr, so `| jq` works cleanly.

2. **A Hydrogen webview app**, for when the user wants to browse interactively:
   ```bash
   adom-mouser app        # opens a "Mouser Search" tab in Hydrogen
   ```
   The app has a search bar, in-stock filter, per-result cards with price breaks, MPN/Mouser-PN copy buttons, datasheet + product-page links, and hover tooltips on every control.

3. **A backend HTTP service** (port 8775), which is what the shared `service-mouser` container runs:
   ```bash
   adom-mouser serve      # MOUSER_API_KEY must be set
   ```
   The CLI and the app both talk to this backend over HTTP (`POST /` with an `{"action":"search"|"part"|"health", ...}` body, or `GET /search?keyword=...`). It caches responses for 10 min and keeps the API key server-side.

There is no MCP server. All access is through the CLI + HTTP service.

## Commands

### `adom-mouser search <keyword>`

Search by keyword, MPN, or Mouser PN.

| Flag | Default | Description |
|---|---|---|
| `--limit N` | 10 | Max results (1–50) |
| `--in-stock-only` | false | Only parts currently in stock |
| `--api URL` / `$MOUSER_API` | auto | Backend URL. If unset, the CLI tries `http://127.0.0.1:8775`, and if that's also down it falls back to calling Mouser directly (requires `MOUSER_API_KEY`) |

Examples:
```bash
adom-mouser search "STM32F103RBT6" --limit 5
adom-mouser search "USB-C connector" --in-stock-only
adom-mouser search "LDO 3.3V 500mA SOT-23"
adom-mouser search "ESP32 WiFi Bluetooth" | jq '.components[].mpn'
```

### `adom-mouser part <part-number>`

Full detail lookup for a specific part. Accepts Mouser PN (`511-STM32F103RBT6`) or MPN (`STM32F103RBT6`). Returns a single-component result with full price-break table and attributes.

```bash
adom-mouser part 511-STM32F103RBT6
adom-mouser part STM32F103RBT6 | jq '.components[0].price_tiers'
```

### `adom-mouser app`

Open the search UI in a Hydrogen webview tab.

| Flag | Default | Description |
|---|---|---|
| `--port N` | 8789 | Local app HTTP server port |
| `--api URL` | auto | Backend to use (same resolution as `search`) |
| `--tab-name S` | "Mouser Search" | Hydrogen tab label |
| `--no-tab` | false | Skip opening the tab (test via curl or browser) |
| `--dev` | false | Enable the `/eval` hot-patch channel |

```bash
adom-mouser app                         # normal use
adom-mouser app --dev                   # enable /eval for UI debugging
adom-mouser app --no-tab --port 8789 &  # local-browser mode
```

When `adom-mouser app` is running, these HTTP endpoints are AI-drivable (no UI clicks needed):

```bash
# run a search via HTTP, watch the UI update live
curl -X POST http://127.0.0.1:8789/search \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"ESP32","limit":5,"inStockOnly":false}'

# state + cached last-search
curl http://127.0.0.1:8789/state | jq

# UI-side console logs (what the frontend JS printed)
curl http://127.0.0.1:8789/console | jq '.messages[-10:]'

# backend-health proxy (so the UI doesn't need CORS to 8775)
curl http://127.0.0.1:8789/backend-health | jq

# shutdown cleanly (removes the Hydrogen tab and exits)
curl -X POST http://127.0.0.1:8789/shutdown
```

### `adom-mouser serve`

Run the backend HTTP proxy. This is what the `service-mouser` container runs.

| Flag | Default | Description |
|---|---|---|
| `--port N` / `$MOUSER_PORT` | 8775 | Port |

Requires `MOUSER_API_KEY`. Endpoints:

```
GET  /health                                  — health + live API ping
GET  /search?keyword=...&limit=10&inStockOnly=false
GET  /part?partNumber=...
POST /              {"action":"search"|"part"|"health", ...}
GET  /              (text/html landing page)
```

### `adom-mouser health`

Check reachability.

```bash
adom-mouser health                 # checks backend (or falls back to Mouser direct)
adom-mouser health --api http://127.0.0.1:8775
```

## What's in a result

Each component in `.components[]` has:

- `mouser_pn`    — Mouser part number, use this for BOM
- `mpn`          — manufacturer part number, use this for schematic/footprint
- `manufacturer` — manufacturer name
- `description`, `category`
- `stock`        — integer count in Mouser's warehouse (live, 10-min cache on backend)
- `stock_text`   — raw Mouser text ("In Stock", "Non-Stocked", etc.)
- `popularity`   — `low` / `medium` / `high` heuristic from stock
- `lead_time`    — factory lead time if ordering more
- `unit_price`   — price at qty 1
- `price_tiers`  — array of `{qty, price}` for quantity price breaks
- `min_order`, `mult` — minimum order + order multiple
- `rohs`         — compliance flag
- `lifecycle`    — New Product / Active / NRND / Obsolete
- `datasheet_url`, `product_url`, `image_url`
- `attributes`   — array of `{name, value}` from the product-attribute table

## Typical workflows

### Finding a part from scratch
```bash
adom-mouser search "32-bit ARM Cortex-M3 microcontroller LQFP-48"
# pick one, then:
adom-mouser part <mouser-pn>
```

### Confirming price for a BOM entry
```bash
adom-mouser part STM32F103RBT6 | jq '.components[0] | {mouser_pn, unit_price, price_tiers, stock}'
```

### Browsing interactively
```bash
adom-mouser app
# then type in the search box, click Product page / Datasheet, etc.
```

## Running the backend

There are two common setups.

### Dedicated `service-mouser` container (shared, has the API key)

The backend proxy runs on a dedicated `default-light` container with `MOUSER_API_KEY` set in `/etc/environment` and a cron watchdog (`service/watchdog.sh`, every 2 min) that (a) keeps the service healthy and (b) auto-pulls `origin/main` + rebuilds when new versions land. Consumer containers point `MOUSER_API` at its public URL:

```
https://mouser-xr8t4f5d01bt.adom.cloud
```

`curl /health` should return `{"ok":true, "api_reachable":true, "version":"X.Y.Z", ...}`. Recover the current URL from `~/service-watcher/services.json` (`mouser` entry, `"primary": true`) if the slug has rotated. To point the CLI at it:

```bash
export MOUSER_API=https://mouser-xr8t4f5d01bt.adom.cloud
adom-mouser search "LM317"
adom-mouser app        # UI reads $MOUSER_API automatically
```

Users don't need to set `MOUSER_API` explicitly — `adom-mouser` is a Tier A app (see `adom-app-model`), so it's installed by every `adompkg install` run from the registry. The CLI autodetects a local `adom-mouser serve` on 127.0.0.1:8775 and falls back to calling Mouser directly if `MOUSER_API_KEY` is set locally.

### Local-only (quick testing)

On any container, if `MOUSER_API_KEY` is set and you run `adom-mouser serve &`, the CLI and the app will autodetect `http://127.0.0.1:8775` and use it. This is the dev-loop path.

## Installation

The binary is distributed as a GitHub release from `adom-inc/adom-mouser`. After downloading to `/usr/local/bin/adom-mouser` and making it executable, run:

```bash
adom-mouser install
```

This deploys the skill to `~/.claude/skills/mouser/SKILL.md` and installs bash completions.

## Notes

- Price data does not include shipping or tariffs.
- Stock is live at query time (10-min cache on the backend).
- Results are sorted by Mouser's internal relevance algorithm, not strictly by stock.
- `MOUSER_API_KEY` is only ever needed on the backend (`serve`) side. Consumer containers just need `MOUSER_API` pointing at a running backend.