Complete manual

One URL in, clean Markdown out — no account, no cloud, and nothing leaves the machine except the fetches you ask for. This manual covers every screen in the app, every option on those screens, and what to do when something fails.

Install and first launch

1. Download the build for your platform: the Windows installer (.exe), the macOS .dmg, or the Linux .deb/.rpm. Every release publishes a SHA256SUMS file next to the installers.
2. Run the installer. On macOS the app is signed and notarized; on Windows the installer is not code-signed yet, so SmartScreen shows one warning on first launch — click More info → Run anyway.
3. Launch Magpie. The first launch shows the end-user licence agreement and one checkbox, Check for updates (a small version file fetched once a day; nothing about you is sent). Press I agree.

Requirements: Windows 10/11, macOS 12+, or Ubuntu 24.04+/Debian 13+ (GTK 4 and WebKitGTK 6.0, pulled in by the packages). A Chrome, Chromium or Edge install makes JavaScript-rendered pages work; without one, Magpie offers a one-time Chromium download of about 150 MB. The window opens at 1200×720 and remembers its size and position.

Only one instance runs per configuration directory. Launching a second one focuses the first instead of racing it for the database.

If you see the window open and immediately close : on Linux, check that WebKitGTK 6.0 is installed (libwebkitgtk-6.0-0). The .deb/.rpm list it as a dependency, so this only bites source builds.

The five-minute tour

The sidebar has two groups. Run: Scrape, Crawl, Search, Watch, Research. Review: Overview, History, Compare. Settings sits at the bottom. The footer shows the crawl status, watch-check count, plan badge, the store path, and the active LLM provider.

Quick win — one scrape, thirty seconds:

1. Open Scrape (Ctrl/Cmd+1).
2. Paste a URL into the address field (placeholder: https://example.com).
3. Press Enter or click Scrape.

The result appears as rendered Markdown, with the final URL, token count, cost and duration in the telemetry bar. That scrape needed no API key; keys are only required for LLM extraction, summarization and research.

Press Ctrl/Cmd+K anywhere for the command palette: type a screen name to jump, scrape example.com to deep-link a scrape, or pick one of the five most recent re-runnable runs. Ctrl/Cmd+1 through 8 follow the sidebar order; Ctrl/Cmd+9 opens Settings. Esc closes any drawer or the palette.

Scrape

One URL in; clean Markdown, extracted JSON or a screenshot out. The screen keeps its form and result while you navigate elsewhere, so a result survives a trip to History and back.

The command bar

1. Paste the URL. A bare host like example.com is accepted and upgraded to https://.
2. The Scrape · Crawl · Watch switch left of the field carries the URL to the other two screens.
3. Press Scrape. While it runs, the button becomes Cancel.

Copy as… shows the exact run as a CLI command, an MCP tool call, or a Go snippet — built from the same options the Scrape button sends, so the two cannot drift. The cost hint beside it prices any LLM calls before the click.

Render and formats

Control	Default	What it does	Change it when
Render: Auto	Auto	Fetches statically first, escalates to a real browser only if the page needs JavaScript	Rarely — this is the right default
Render: Browser	—	Always renders in a browser	The page is a known SPA and you want to skip the static attempt
Render: Static	—	Never launches a browser	You want the raw server response, or have no browser
Formats	markdown	Chips: markdown, llm, text, json, html, raw — each picked format renders a tab from the same fetch	You feed a pipeline that wants JSON or raw HTML

Screenshot is not a format chip; it is the Viewport tab, which captures the page in a browser on demand.

The extractor chips

The chip row after Formats picks one extractor: off, auto (dispatch by URL pattern), schema, or one of the verticals. The verticals are zero-LLM extractors — GitHub repos, Hacker News, YouTube, arXiv, PyPI, npm, crates.io, Docker Hub, Hugging Face, Stack Overflow, Substack, Dev.to, Reddit, RSS, Trustpilot, Upwork jobs, Amazon, eBay, Etsy, Shopify, WooCommerce and generic e-commerce products, plus article, event, job-posting and local-business pages — 27 in all, each matching its own URL patterns. Hover a chip for its description.

schema opens the Schema panel:

1. Describe what you want in What do you want? — for example “book title, price, stock availability and UPC” — and press Draft schema. An LLM drafts it from your description plus the scraped page; the draft lands in the editor under a badge naming the provider, tokens and cost.
2. Edit the text — JSON or YAML, pasted or drafted. The edited badge marks unsaved changes.
3. Pick a saved schema from the dropdown, or New schema to detach and keep the editor text. Saved schemas are plain files in the schemas folder next to config.yaml.
4. Name it under Save as and save; the schema joins the library and the Crawl screen’s picker.

Advanced options

Open the Advanced dropdown for the full option surface:

Option	Default	What it does	Change it when
Include (CSS)	empty	One selector per line, kept in the cleaned output	The boilerplate stripper keeps something you don’t want
Exclude (CSS)	empty	One selector per line, dropped — wins over include	Nav or footer fragments survive cleaning
Bypass selector cache	off	Skips the per-domain selector cache for this run	A cached selector returns stale fields after a site redesign
Capture XHR	empty	Comma-separated regexps; records matching background requests (Browser render only)	The data loads via API calls, not the DOM
Actions	empty	One browser action per line: click, type, scroll, wait, wait-for, eval-js	Content appears only after interaction
Language	Settings default	Accept-Language override	You need a localized variant of the page
TLS fingerprint	Settings default	Browser TLS handshake: chrome, firefox, safari, edge, ios, chrome_android	A site blocks non-browser TLS clients
Header profile	default	Browser-like HTTP headers: default, chrome, firefox, safari, edge, ios, chrome_android	A site rejects unknown clients
Cookies	empty	Sent with the request, a=b; c=d	You copied a session by hand
Viewport	empty	Screenshot size, WxH	You need a specific capture size
CDP endpoint	empty	Drives your already-running Chrome (ws://127.0.0.1:9222)	You need your real logged-in browser
Proxy	Settings default	Per-run egress: http://user:pass@host:port or a pool line; invalid values fail before any request	Corporate network or geo requirements
Provider override	Settings default	LLM provider for this run	Testing one provider on one page
Model override	empty	LLM model for this run	A cheaper model for bulk runs
API key (this run)	empty	Applies to this run’s provider only, never stored	A throwaway or scoped key
Max cost USD	0 = off	USD ceiling on this run’s LLM spend	Unbounded extraction would get expensive

The result workstation

Tabs across the result: Markdown Render, one tab per picked format, Extracted JSON (when a record exists), XHR, Brand, and Viewport. Tools above the tabs: Summarize (an LLM condenses the page to 1–20 sentences; the count and cost show in the panel), Brand (zero-LLM: the page’s palette, font families, logo and favicon), a Wrap toggle, Copy, Save as file, and Discard result. Copy and Save always act on the visible tab; the Viewport tab saves the captured screenshot as page.png.

On a format tab, Re-extract runs the Schema panel’s schema over the tab’s content without refetching. With a vertical selected it is disabled — verticals fetch the URL themselves.

If you see “This site blocked us” : the site served a bot challenge. Press Retry with Browser render; if that fails too, the site’s defenses hold and Magpie will not defeat them.

If you see “Extraction failed — the fetched page is below” : the fetch succeeded but the LLM step did not. A missing API key adds an Open Settings button; set the key and press Re-extract.

If you see “Session expired for <host>” : a captured login rode the request and the page hit an auth wall. Press Re-login to open a fresh capture window (see Settings → Sessions).

If you see “Session ✓” next to the URL field : a captured session for that host will attach automatically.

Crawl

Follow links from one seed URL and collect every page as records.

Crawls run in the background: leave the screen, keep working, and the footer tracks progress. One crawl counts as one run against the trial.

Start a crawl

1. Open Crawl (Ctrl/Cmd+2).
2. Pick Mode: Corpus (no LLM) collects pages as Markdown records; Extracted (schema) applies a schema per page.
3. In Extracted mode, pick a schema. The list comes from the schemas folder; save schemas there from the Scrape screen’s panel.
4. Enter the Seed URL (placeholder: https://quotes.toscrape.com). The sitemap feeds the queue first.
5. Set Max pages (at least 1; the form starts at 25) and Max depth (starts at 2; 0 = the seed page only). Leave Same host on to stay on one site.
6. Press Start crawl.

Preview seed URLs runs the sitemap read without crawling: the URL list, a truncated badge when the sitemap is large, and a copy button. Author include/exclude globs against this list before starting.

Option	Default	What it does	Change it when
Mode	Corpus	Corpus bills nothing; Extracted applies the schema per page	You want structured records, not Markdown
Max pages	25	Hard cap on fetched URLs	Bigger targets; 25 is a sane first look
Max depth	2	Link-hops from the seed; 0 = the seed page only	Deeper trees
Same host	on	Restricts the crawl to one host	You want a multi-domain walk
Path prefix	empty	Only URLs under this path	One subtree, e.g. /docs/
Include globs	empty	Comma-separated URL globs kept	Only some paths are wanted
Exclude globs	empty	URL globs dropped — wins over include	Skip tag pages, APIs
Allow subdomains	off	Follows subdomains of the seed host	blog.+site layouts
No sitemap	off	Skips the sitemap feed	You want pure link discovery
Sitemap only	off	Only URLs from the sitemap	Enumerate without crawling links
Concurrency	0 = core default	Fetch workers	Tuned bulk runs
Rate (rps)	0 = core default	Per-host requests per second	Politeness or speed
Cost ceiling $	0 = config default	LLM spend guard (Extracted mode)	Bounded spend
TLS fingerprint / Language / Proxy	Settings defaults	Same meaning as Scrape	Same triggers as Scrape
Auto-throttle on errors	off	Slows down when pages fail	Flaky targets

If you see “Extracted mode bills LLM calls” : that is a notice, not an error. Extraction bills until Magpie learns CSS selectors for the site — after a few pages agree, later pages and later scrapes with the same schema extract free. The cost ceiling guards the learning phase.

The run panel

While the crawl runs: a status pill, the run id, live counters (ok, err, records), a progress bar against the page cap, and a per-page feed. Stop ends the run and keeps what it collected. After it ends: New crawl returns to the form, Copy run id copies the identifier for History, and the records table shows the first 50 rows.

Export records as jsonl, json, csv or sqlite through the native save dialog; Open folder reveals them on disk. Corpus runs export jsonl/json only — the same rule the CLI enforces. Records live in per-run files (<runId>.jsonl, plus numbered .part files after a resume).

If you see “Blocked by robots.txt” : the site disallows this crawl. Try a narrower seed or path prefix. Magpie respects robots.txt by design.

If you see “Run failed” : the detail carries the terminal error; per-page failures show inline in the feed without ending the run. Telemetry — LLM calls, cost, per-page counts — is in History for the run id.

Search

Query any of six engines, then scrape a hit in one click. Engines: Brave, DuckDuckGo, Exa, SearXNG, SerpAPI, Serper. DuckDuckGo works with no key.

1. Open Search (Ctrl/Cmd+3). Type the query, press Enter or Search.
2. Pick the engine on the strip. Keyed engines show an API key — <engine> field that pays for this search only and is never stored.
3. Set Scrape top to 3, 5 or 10 to fetch the top hits’ Markdown in the same call; each opens under its result card, with the error verbatim when a hit couldn’t be fetched.
4. Result count: 10, 25 or 50.

Each result card offers Scrape this (deep-links the Scrape screen with the URL filled in), Crawl this site (seeds Crawl on the hit’s host — disabled while another crawl runs), and Open in browser (the system browser; only http/https URLs reach it).

If you see “No <engine> key” : save a key in Settings → Keys, set the engine’s environment variable, or paste one for this search only.

Watch

Snapshot pages on a schedule and see exactly what changed. Watches check while the app is open — keep it in the tray (Settings → Background) for round-the-clock checks. A watch counts once against the trial, when added.

Add a watch

1. Open Watch (Ctrl/Cmd+4). Paste the URL.
2. Pick an interval: 5m, 15m, 1h, 6h, 24h, or custom… (any number of minutes, 1 to a year).
3. Press Watch.

Advanced: a Name (shown instead of the URL), the interval as a number, Send changes to (a registered webhook endpoint), Render (auto, static or browser) and Accept-Language for locale-variant pages.

The table and drawer

Columns: Watch, Every, Last checked, Changed, Next check, Hook. The Changed cell shows a badge — pending before the first check, same, changed, or stale (three intervals overdue) — plus a failing badge with the error on hover. Row actions: Check now, Pause/Resume, View diff, and delete with a confirm step.

Clicking a row opens the drawer: metadata, an editable Name with Save name, Send changes to with Save route, the Last change word diff (kept across restarts), the Snapshot history table (checked-at, content hash, changed), and Open in Compare, which deep-links the newest snapshot into the Compare screen.

The scheduler checks at most two pages at once, one check bounded at five minutes, on a 30-second tick. Diff text crossing the bridge is capped at 4 KB.

Research

Plan, read, verify every quote, write a report you can audit. Research is the one screen that always needs an LLM key; everything it cites is an exact quote from a stored page snapshot, checked against the page that produced it.

Compose a run

1. Open Research (Ctrl/Cmd+5). Type the question (up to 2,000 characters; Ctrl/Cmd+Enter runs it).
2. Pick Effort: quick, standard or deep. Each segment’s label carries its own projection — sub-researchers × tool calls — and the cap beside Run is the guarantee, never the estimate.
3. Press Run.

The Advanced drawer controls sources: Allow (read only these domains and subdomains), Deny, Prefer (ranked up), Read with my login (saved sessions; the first use per domain asks for a one-time acknowledgement of the terms — read-only, one page every 10 s per site), From/To publication dates, Search backends (none picked = the keyless ones), Writer and Judge provider/model pairs, the Cap $ (blank = Settings’ max, else $1.00; the run stops researching at 85% of it), and Review the plan first.

The run panel

Live phases show as a pill: planning, review, running, writing. The budget meter fills against the cap; counters track facts and usable facts. While it runs:

• Steer — type a message; the run reads the latest one at its next step.
• Write now — skip to the report from what is verified. Disabled until the plan exists.
• Stop — keeps the checkpoint; Resume continues the same run, optionally with a higher cap.

With Review the plan first on, the run pauses after planning for approve or redraft. The activity log streams every step; the couldn’t-read list names each unreachable page and why (login-required, access-denied, unavailable, empty, challenge, robots, error).

The report

The finished report renders with citation chips — each chip toned by its fact’s verdict (verified, softened, contested). Clicking a chip opens the evidence drawer: the claim, the exact quote, the passage around it, the URL and the checked-at timestamp. Below the report: the verification panel, the findings table (the whole ledger, dropped rows included), the cited sources, and Export — Markdown, Sources CSV (footnote, url, quote, checked_at, content_hash) and BibTeX. DOCX/PDF is a copied pandoc line; the app ships no exporter.

Run again repeats the question with the same options and approved plan, then shows what changed. Compare with diffs the evidence against an earlier run of the same question: sources added and gone, pages changed, facts added, gone, and quotes whose verdict moved. Recent research lists the newest five runs; Forget deletes a run, every page copy it stored and its read trail (its spend stays in the budget history).

If you see “Research can’t start” : the reason is stated — usually a missing key (Open Settings takes you there) or the monthly budget being reached.

Overview

The landing screen. A quick scrape bar (URL + Enter deep-links Scrape), four tiles — runs this week, pages fetched this week, LLM spend this month against the optional budget, watches — then, once you have runs: the activity card (runs per day, spend, where it went), and this week’s failures grouped by reason with one-click remedies. Before the first run, a getting-started checklist replaces them; each done row can be dismissed.

Below: the five action cards, the agent hookup tile (the MCP server’s status, Start MCP server, Copy for Claude Code, Add to Claude Desktop, Add to Cursor — see Integrations), the watch pulse (changed in the last 24 h, failing, next check) and the sessions tile. The newest runs close the page; a row opens the same drawer History uses.

If you see “Monthly LLM budget reached” : metered LLM calls are paused until the 1st or until the budget is raised. Flat-plan and local providers still run. Raise it in Settings → Budget.

History

Every scrape and crawl from this app and the CLI — one shared SQLite store. Filter by type (All, Scrape, Crawl, Other), status (Any, Finished, Failed, Running, Stopped), dates (YYYY-MM-DD, typed text by design: a native date input paints today as a set range on WebKitGTK), and a substring over run id or command. Filters combine; Clear resets them.

Click a row for the drawer:

status, timing, pages ok/err, fetch volume, tokens, LLM cost, proxy, and the verbatim error. Tabs: Output (the kept result — a scrape’s Markdown and extracted record, a crawl’s records preview and export), Reproduce (the run as CLI, MCP tool call, or Go — options the desktop saved; CLI runs and older runs keep none), and LLM calls (purpose, provider, model, tokens, USD per call).

Stopped or failed crawls offer Resume (continues without refetching done pages; earlier records stay in the export) and Re-run (fills the Crawl form fresh). Research rows offer Open in Research.

If you see “History unavailable” : another Magpie process holds the database lock. Close the other instance — the CLI included — and reopen the screen.

Compare

Pick two sides of one URL and read the word diff.

1. Open Compare (Ctrl/Cmd+8). Enter the URL both sides came from.
2. Press Load sides. Every scrape and watch check leaves a snapshot; runs are listed too.
3. Pick Snapshots or Runs, choose left and right, press Compare.

The result shows both sides’ Markdown side by side and the diff below (additions and deletions colored).

Copy diff copies the text; Export… writes it through the save dialog. Identical sides show “Nothing moved”. The Watch drawer’s Open in Compare lands here with the URL and newest snapshot pre-filled.

Settings

Ctrl/Cmd+9. Cards top to bottom:

Plan

The free trial is 5 runs; failed and stopped runs don’t count, a crawl is one run, and a watch counts once when added. When the trial is used (or a licence lapses), the app turns read-only — every read, export and setting keeps working; the run buttons explain themselves. Activate a licence key from the purchase email, Check again to re-validate, Manage devices for the Polar portal, or Remove this device (goes read-only here; runs and history stay). A licence is $49/month, one computer at a time, and tolerates 14 days offline.

Providers

Seven LLM providers: anthropic, openai, openrouter, opencode-go, opencode-zen (keys required), plus ollama (local) and codex (flat) — no key. Pick the default provider chip, set the Model (blank = the provider’s default), press Apply. The line beneath shows the session pair and the saved pair.

For a keyed provider, the API key section shows where the current key comes from (session, env, keyring, sealed file, or none) and never displays a stored value. Use for this session overrides until the app quits; Save persists to the OS keychain; Test spends one token and reports the model, latency in ms, and token counts — a 401 is the diagnosis. Environment variables (MAGPIE_<PROVIDER>_API_KEY) still work and are marked “may be stale”.

Keys

Credentials beyond LLM providers: search-engine keys (Brave, Exa, SerpAPI, Serper), the SearXNG URL, and site-extractor credentials (GitHub token, Reddit app). Each row shows its source badge — env values win over stored ones — and saved values are never shown again. Stored in the OS keyring, or sealed into keys.json where no keyring exists.

Sessions

Log in once; Magpie reuses the session. Enter a Login URL and press Log in to a site: a real browser window opens with a capture bar at the bottom. You do the logging in — 2FA, SSO and CAPTCHA all work; tick “remember me” so it lasts. The bar’s button moves from Capture now to Save session once a sign-in is detected; the window closes on a 5-minute timeout. The table lists domains, status (an expired badge means the last attached scrape hit an auth wall), capture time and last use. Cookie values never leave the store.

Appearance

Density (Comfortable/Compact, applies immediately), theme (Dark/Light, also the header toggle), and window geometry — remembered automatically, restored on the next start.

Budget

A monthly LLM budget in USD. 0 = off. The Overview meter warns at 80%; metered LLM calls stop at 100% until the 1st or until you raise it. Flat-plan and local providers never stop; CLI runs count toward the budget but are not stopped by it.

Network

Defaults that prefill the Scrape and Crawl forms: a Proxy pool (one URL per line — http(s) or socks5, or host:port:user:pass; invalid lines are rejected on save), a Default fingerprint, and a Default language. Per-run values still win.

Integrations

The MCP server: 12 stateless tools over Streamable HTTP, bound to 127.0.0.1 only — never the LAN. Toggle it on; the badge reads running with the endpoint beside it and a Copy endpoint button. Require a token adds a bearer check (the token is copied, never displayed; New token invalidates the old one and connected agents must reconnect). The MCP port field is used when the server starts; blank picks a free port and keeps it. The Overview screen’s agent tile adds one-click registration for Claude Code (its own CLI line), Claude Desktop and Cursor (merged config entries). The server needs an active licence and comes back on at launch once started.

Webhooks

Signed POSTs — Standard Webhooks, HMAC-SHA256 — when a watch changes or a crawl ends. Add endpoint: a name, a URL (localhost and LAN are fine), and events (watch.changed, crawl.finished, crawl.failed). The signing secret is shown once at add time and on rotation; verify with any Standard Webhooks library using the webhook-id, webhook-timestamp and webhook-signature headers. Per endpoint: Send test, edit, Rotate secret, pause and delete, plus a delivery log of the last 20 attempts. Failed deliveries retry 3 times over about 30 seconds. A watch can also send only to one endpoint via its Send changes to setting.

Background

Keep running in the tray when closed — closing hides Magpie and watches keep checking; quit from the tray menu. Notify when a watch changes — an OS notification whose Open action raises the window. Start at login — opens hidden in the tray when Keep running is on. Where the desktop offers no tray or notification server, the toggles read off and say so.

Data

The store path (SQLite, shared with the CLI), the config path, the version, and the store size. Open folder reveals the data directory; Clear selector cache empties it. If the store still sits at the pre-v0.1.30 cache path, a warning shows the exact move steps — cache cleaners empty that folder.

Cache inspector

One row per domain the selector cache has synthesized selectors for: schemas, selectors, samples used, last synthesized. Heal drops the domain’s cached selectors; the next scrape re-synthesizes them with an LLM pass. Healing never runs the scrape for you.

About

The running version (copyable), the daily update check toggle and Check now (dev builds never check; the result or its verbatim error shows inline), Open log folder for support, and the expandable EULA and third-party licence notices.

Reference

Keyboard

Keys	Action
Ctrl/Cmd+K	Command palette (type a screen, scrape <url>, or re-run)
Ctrl/Cmd+1 … 8	Screens in sidebar order (position-based; AZERTY-safe)
Ctrl/Cmd+9	Settings
Enter	Submit the focused URL field
Esc	Close the open drawer, dialog or palette

Files

Path	Contents
<data>/magpie/cache.db	The shared SQLite store (history, snapshots, selector cache)
<config>/config.yaml	Core config (provider/model, caps) — shared with the CLI
<config>/desktop.json	Desktop preferences (theme, density, window, plan ledger)
<config>/schemas/	The schema library, beside config.yaml
<data>/magpie/records/	Per-run records and scrape replays, beside the store
OS keychain	Provider keys, webhook secrets, licence record

Settings → Data and the footer print the exact store path on this machine. The config dir is ~/.config/magpie on Linux and macOS (XDG_CONFIG_HOME respected), %APPDATA%\magpie on Windows. A fresh install puts the store in the OS data dir — ~/.local/share/magpie/ on Linux, %LOCALAPPDATA%\magpie\ on Windows, ~/Library/Application Support/magpie/ on macOS; installs from before v0.1.30 keep ~/.cache/magpie/cache.db, which is why Settings warns about it.

Trial and licence

5 free runs (failed and stopped runs are free; a crawl is one run; a watch counts once when added). $49/month, one computer at a time, 14-day offline allowance. Read-only when locked: runs, history and exports stay available.

Troubleshooting

Empty Markdown on a JavaScript site — the static fetch returned a shell. Set Render to Browser, or click Retry with Browser render on the blocked notice.

The data is in the network tab, not the page — turn on Capture XHR with a pattern like /api/.* and read the XHR tab.

A site that worked yesterday returns a challenge — defenses change. Try a TLS fingerprint and a browser header profile. Magpie detects and reports challenges; it does not defeat them.

Extraction returns empty or wrong fields — the cached selectors are stale after a redesign. Settings → Cache inspector → Heal the domain, then re-run; or tick Bypass selector cache for one run.

“Extraction failed” with the page still shown — the fetch worked, the LLM step didn’t. Usually a missing key (the Open Settings button appears) or a spent cost cap.

A keyed feature says “missing API key” — set it in Settings → Providers (per-provider), press Test, and retry. Session keys die with the app; saved ones don’t.

“Settings unavailable” / “History unavailable” — another Magpie process holds the store lock. Close the other instance, CLI included.

Watch checks stopped — the app must be running. Enable Settings → Background → Keep running in the tray, and Start at login if you want it always on.

MCP tools refuse with a plan error — the in-app MCP server needs an active licence. Settings → Plan shows the state.

A saved login stopped working — the Sessions row shows an expired badge after a scrape hits an auth wall. Delete the row and capture again, or press Re-login on the scrape that noticed.

What’s next

• Every CLI flag behind these screens: the magpie README (github.com/motherlodelab/magpie)
• The MCP tool list for agents: the README’s MCP server section
• Deeper pages per screen: doc-scrape-reference, doc-watch, doc-research (write on request)