@tikoci/rosetta 0.3.1 → 0.4.0

package/README.md

@@ -1,66 +1,111 @@
 # rosetta
 
-MCP server for searching [MikroTik RouterOS documentation](https://help.mikrotik.com/docs/spaces/ROS/overview). Gives your AI assistant searchable access to 317 documentation pages, 4,860 property definitions, 40,000-entry command tree, and 144 hardware product specs — with direct links to help.mikrotik.com.
+MCP server that gives AI assistants searchable access to the complete [MikroTik RouterOS documentation](https://help.mikrotik.com/docs/spaces/ROS/overview) — 317 pages, 4,860 properties, 40,000-entry command tree, hardware specs for 144 products, and direct links to help.mikrotik.com.
 
-Tested with **Claude Desktop**, **Claude Code**, **VS Code Copilot** (including Copilot CLI), **Cursor**, and **OpenAI Codex** on macOS, Linux, and Windows.
+If you need MikroTik docs, you likely have a MikroTik. Install rosetta once as a container on your router using [RouterOS /app](#install-on-mikrotik-app), and any AI assistant on the network can use it. Or [run it locally](#install-locally-with-bun) on your workstation.
 
-## What is SQL-as-RAG?
+### SQL-as-RAG
 
-Most retrieval-augmented generation (RAG) systems use vector embeddings to search documentation. This project takes a different approach: **SQLite [FTS5](https://www.sqlite.org/fts5.html) full-text search as the retrieval layer** — what we call SQL-as-RAG.
+Instead of vector embeddings, rosetta uses **SQLite [FTS5](https://www.sqlite.org/fts5.html) full-text search** as the retrieval layer — SQL-as-RAG. For structured technical docs, [BM25 ranking](https://www.sqlite.org/fts5.html#the_bm25_function) with [porter stemming](https://www.sqlite.org/fts5.html#porter_tokenizer) beats vector similarity: terms like `dhcp-snooping` and `/ip/firewall/filter` are exact tokens, not fuzzy embeddings. No API keys, no vector database — just a single SQLite file that searches in milliseconds.
 
-For structured technical documentation like RouterOS, full-text search with [BM25 ranking](https://www.sqlite.org/fts5.html#the_bm25_function) beats vector similarity. Technical terms like "dhcp-snooping" or "/ip/firewall/filter" are exact tokens — [porter stemming](https://www.sqlite.org/fts5.html#porter_tokenizer) and proximity matching handle the rest. No embedding pipeline, no vector database, no API keys. Just a single SQLite file that searches in milliseconds.
-
-The data flows: **HTML docs → SQLite extraction → FTS5 indexes → MCP tools → your AI assistant.** The database is built once from MikroTik's official Confluence documentation export, then the MCP server exposes 11 search tools over stdio or HTTP transport.
-
-## What's Inside
+### What's Inside
 
 - **317 documentation pages** from MikroTik's official help site (~515K words)
 - **4,860 property definitions** with types, defaults, and descriptions
 - **5,114 commands** in the RouterOS command hierarchy (551 directories, 34K arguments)
 - **1,034 callout blocks** — warnings, notes, and tips with important caveats
 - **144 hardware products** — CPU, RAM, storage, ports, PoE, wireless, license level, pricing
+- **2,874 performance benchmarks** — ethernet and IPSec throughput test results for 125 devices (64/512/1518-byte packets, multiple routing/bridging modes), plus block diagrams for 110
 - **46 RouterOS versions tracked** (7.9 through 7.23beta2) for command history
 - Direct links to help.mikrotik.com for every page and section
 
-## Quick Start
+---
 
-## MCP Discovery Status
+## Install on MikroTik (/app)
 
-- GitHub MCP Registry listing: planned
-- Official MCP Registry publication: metadata is now prepared in `server.json`
+RouterOS 7.22+ includes the [/app](https://help.mikrotik.com/docs/spaces/ROS/pages/328068) feature for running containers directly on the router. This is the simplest way to deploy rosetta — install once, and any AI assistant on your network can connect to the MCP endpoint URL shown in the router UI.
 
-Local install remains the primary path today (`bunx @tikoci/rosetta`).
+**Requirements:** RouterOS 7.22+, x86 or ARM64 architecture (CCR, RB5009, hAP ax series, CHR, etc.), container package installed, device-mode enabled.
 
-When ready to publish to the official registry:
+### 1. Enable containers (two reboots required)
 
-```sh
-brew install mcp-publisher
-mcp-publisher validate server.json
-mcp-publisher login github
-mcp-publisher publish server.json
+If you haven't already enabled the container package and device-mode:
+
+```routeros
+# Install the container package (router reboots automatically)
+/system/package/update/check-for-updates duration=10s
+/system/package/enable container
+# Apply changes restarts the router
 ```
 
-After publication, the server should be discoverable via:
+After reboot:
 
-```sh
-curl "https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github.tikoci/rosetta"
+```routeros
+# Enable container device-mode (requires physical power cycle or button press — follow the on-screen prompt)
+/system/device-mode/update mode=advanced container=yes
 ```
 
-### Option A: Install with Bun (recommended)
+See MikroTik's [Container documentation](https://help.mikrotik.com/docs/spaces/ROS/pages/Container) for full prerequisites and troubleshooting.
+
+### 2. Add the rosetta app
+
+```routeros
+/app/add use-https=yes disabled=no yaml="name: rosetta
+descr: \"RouterOS Docs for AI assistants - use URL as MCP server\"
+page: https://tikoci.github.io/p/rosetta
+category: development
+icon: https://tikoci.github.io/p/rosetta.svg
+default-credentials: \"none - just use 'ui-url' as the MCP server in your AI assistant\"
+url-path: /mcp
+auto-update: true
+services:
+  rosetta:
+    image: ghcr.io/tikoci/rosetta:latest
+    container_name: mcp-server
+    ports:
+      - 9803:8080/tcp:web
+"
+```
 
-Zero install, zero config, no binary signing issues. Requires [Bun](https://bun.sh/) — no Gatekeeper or SmartScreen warnings since there's no compiled binary to sign.
+That's it. RouterOS downloads the container image, configures networking and firewall redirects, and starts the MCP server. The `auto-update: true` setting pulls the latest image on each boot.
 
-**1. Install Bun** (if you don't have it):
+### 3. Get the MCP endpoint URL
 
-```sh
-# macOS / Linux
-curl -fsSL https://bun.sh/install | bash
+The URL to use with your AI assistant is shown as **UI URL** in WebFig (App → rosetta), or from the CLI:
 
-# Windows
-powershell -c "irm bun.sh/install.ps1 | iex"
+```routeros
+:put [/app/get rosetta ui-url]
 ```
 
-**2. Configure your MCP client** with `bunx @tikoci/rosetta` as the command. No setup step needed — the database downloads automatically on first launch (~50 MB compressed).
+This URL includes the `/mcp` path and is ready to paste into any MCP client that supports HTTP transport. With `use-https=yes`, the URL uses HTTPS with a MikroTik-managed `*.routingthecloud.net` certificate.
+
+### 4. Configure your AI assistant
+
+Point any HTTP-capable MCP client at the URL from the previous step:
+
+```json
+{ "url": "https://app-rosetta.XXX.routingthecloud.net/mcp" }
+```
+
+> **CHR note:** Cloud Hosted Router in free or trial mode does not include the `/ip/cloud` service needed for HTTPS certificates. Set `use-https=no` on the /app — the URL will use HTTP instead. The UI URL always reflects the correct protocol.
+
+> **HTTP option:** On any platform, you may choose `use-https=no` if you prefer HTTP or are on an isolated network. 
+
+---
+
+## Install Locally (with Bun)
+
+Run rosetta on your workstation using [Bun](https://bun.sh/). The MCP server runs over stdio — no network configuration needed. The database downloads automatically on first launch (~50 MB compressed).
+
+### Quick setup
+
+```sh
+bunx @tikoci/rosetta --setup
+```
+
+This downloads the database and prints config snippets for all supported MCP clients. Copy-paste the config for your client and you're done.
+
+### Or configure manually
 
 <details>
 <summary><b>VS Code Copilot</b></summary>
@@ -98,8 +143,6 @@ Edit your Claude Desktop config file:
 - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
 - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
 
-Add (or merge into existing config):
-
 ```json
 {
   "mcpServers": {
@@ -111,22 +154,9 @@ Add (or merge into existing config):
 }
 ```
 
-> **PATH note:** Claude Desktop on macOS doesn't always inherit your shell PATH. If `bunx` isn't found, use the full path — typically `~/.bun/bin/bunx`. Run `which bunx` to find it, or use `bunx @tikoci/rosetta --setup` which prints the full-path config for you.
-
-Then **restart Claude Desktop**.
-
-</details>
-
-<details>
-<summary><b>GitHub Copilot CLI</b></summary>
-
-Inside a `copilot` session, type `/mcp add` to open the interactive form:
+> **PATH note:** Claude Desktop on macOS doesn't always inherit your shell PATH. If `bunx` isn't found, use the full path (typically `~/.bun/bin/bunx`). Run `bunx @tikoci/rosetta --setup` to print the full-path config.
 
-- **Server Name:** `routeros-rosetta`
-- **Server Type:** 2 (STDIO)
-- **Command:** `bunx @tikoci/rosetta`
-
-Press <kbd>Tab</kbd> to navigate fields, <kbd>Ctrl+S</kbd> to save.
+Restart Claude Desktop after editing.
 
 </details>
 
@@ -155,21 +185,38 @@ Open **Settings → MCP** and add a new server:
 codex mcp add rosetta -- bunx @tikoci/rosetta
 ```
 
-> **Note:** ChatGPT Apps require a remote HTTPS MCP endpoint and cannot use local stdio servers like this one. Codex (CLI and desktop app) supports stdio and works with `bunx`.
+> **Note:** ChatGPT Apps require a remote HTTPS MCP endpoint. Use the [MikroTik /app install](#install-on-mikrotik-app) or another container platform for a hosted endpoint, or Codex CLI for local stdio.
 
 </details>
 
-**That's it.** First launch takes a moment to download the database; subsequent starts are instant. The database is stored in `~/.rosetta/ros-help.db`.
+<details>
+<summary><b>GitHub Copilot CLI</b></summary>
+
+Inside a `copilot` session, type `/mcp add`:
+
+- **Server Name:** `routeros-rosetta`
+- **Server Type:** 2 (STDIO)
+- **Command:** `bunx @tikoci/rosetta`
+
+</details>
+
+**Install Bun** (if you don't have it):
+
+```sh
+# macOS / Linux
+curl -fsSL https://bun.sh/install | bash
+
+# Windows
+powershell -c "irm bun.sh/install.ps1 | iex"
+```
 
-> **Verify it works:** Run `bunx @tikoci/rosetta --setup` to see the database status and print config for all MCP clients.
->
-> **Auto-update:** `bunx` checks the npm registry each session and uses the latest published version automatically. No manual update needed. (Note: the `~/.rosetta/ros-help.db` database persists across updates — it's re-downloaded only when missing or when you run `--setup --force`.)
+> **Auto-update:** `bunx` checks the npm registry each session and uses the latest published version automatically. The database in `~/.rosetta/ros-help.db` persists across updates.
 
-### Option B: Pre-built binary (no runtime needed)
+---
 
-Download a compiled binary from [Releases](https://github.com/tikoci/rosetta/releases) — no Bun, Node.js, or other tools required.
+## Install from Binary
 
-**1. Download** the ZIP for your platform from the [latest release](https://github.com/tikoci/rosetta/releases/latest):
+Download a compiled binary from [Releases](https://github.com/tikoci/rosetta/releases) — no Bun, Node.js, or other runtime needed.
 
 | Platform | File |
 |----------|------|
@@ -178,23 +225,16 @@ Download a compiled binary from [Releases](https://github.com/tikoci/rosetta/rel
 | Windows | `rosetta-windows-x64.zip` |
 | Linux | `rosetta-linux-x64.zip` |
 
-Extract the ZIP to a permanent location (e.g., `~/rosetta` or `C:\rosetta`).
-
-**2. Run setup** to download the database and see MCP client config:
-
 ```sh
-./rosetta --setup
+./rosetta --setup    # downloads DB + prints MCP client config
 ```
 
-On Windows: `.\rosetta.exe --setup`
-
-> **macOS Gatekeeper:** If macOS blocks the binary: `xattr -d com.apple.quarantine ./rosetta` or go to **System Settings → Privacy & Security → Allow Anyway**.
->
+> **macOS Gatekeeper:** `xattr -d com.apple.quarantine ./rosetta` or System Settings → Privacy & Security → Allow Anyway.
 > **Windows SmartScreen:** Click **More info → Run anyway**.
 
-**3. Configure your MCP client** using the config printed by `--setup`. It uses the full path to the binary — paste it into your MCP client's config as shown.
+---
 
-### Try It
+## Try It
 
 Ask your AI assistant questions like:
 
@@ -204,6 +244,7 @@ Ask your AI assistant questions like:
 - *"What are the firewall filter default chains?"*
 - *"Show me warnings about hardware offloading"*
 - *"Which MikroTik routers have L3HW offload, and more than 8 ports of 48V PoE? Include cost."*
+- *"Compare the RB5009 and CCR2004 IPSec throughput at 1518-byte packets."*
 
 ## MCP Tools
 
@@ -219,7 +260,7 @@ The server provides 11 tools, designed to work together:
 | `routeros_search_callouts` | Search warnings, notes, and tips across all pages |
 | `routeros_search_changelogs` | Search parsed changelog entries — filter by version range, category, breaking changes |
 | `routeros_command_version_check` | Check which RouterOS versions include a command |
-| `routeros_device_lookup` | Hardware specs for 144 MikroTik products — filter by architecture, RAM, storage, PoE, wireless, LTE |
+| `routeros_device_lookup` | Hardware specs for 144 MikroTik products — filter by architecture, RAM, storage, PoE, wireless, LTE. Includes ethernet/IPSec benchmarks and block diagrams for most devices |
 | `routeros_stats` | Database health: page/property/command counts, coverage stats |
 | `routeros_current_versions` | Fetch current RouterOS versions from MikroTik (live) |
 
@@ -232,15 +273,15 @@ The AI assistant typically starts with `routeros_search`, then drills into speci
 | **First launch is slow** | One-time database download (~50 MB). Subsequent starts are instant. |
 | **`npx @tikoci/rosetta` fails** | This package requires Bun, not Node.js. Use `bunx` instead of `npx`. |
 | **`npm install -g` then `rosetta` fails** | Global npm install works if Bun is on PATH — it delegates to `bun` at runtime. But prefer `bunx` — it's simpler and auto-updates. |
-| **ChatGPT Apps can't connect with `bunx @tikoci/rosetta`** | Expected: ChatGPT Apps supports remote HTTPS MCP endpoints, not local stdio command launch. Use OpenAI Codex for local stdio, or deploy/tunnel a remote MCP URL for ChatGPT. |
+| **ChatGPT Apps can't connect** | ChatGPT Apps require a remote HTTPS MCP endpoint. Use the [MikroTik /app install](#install-on-mikrotik-app) for a hosted endpoint, or Codex CLI for local stdio. |
 | **Claude Desktop can't find `bunx`** | Claude Desktop on macOS may not inherit shell PATH. Use the full path to bunx (run `which bunx` to find it, typically `~/.bun/bin/bunx`). `bunx @tikoci/rosetta --setup` prints the full-path config. |
 | **macOS Gatekeeper blocks binary** | Use `bunx` install (no Gatekeeper issues), or: `xattr -d com.apple.quarantine ./rosetta` |
 | **Windows SmartScreen warning** | Use `bunx` install (no SmartScreen issues), or click **More info → Run anyway** |
-| **How to update** | `bunx` always uses the latest published version. For binaries, re-download from [Releases](https://github.com/tikoci/rosetta/releases/latest). |
+| **How to update** | `bunx` always uses the latest published version. For binaries, re-download from [Releases](https://github.com/tikoci/rosetta/releases/latest). MikroTik /app with `auto-update: true` pulls the latest image on each boot. |
 
 ## HTTP Transport
 
-Most MCP clients use stdio (the default). Some — like the OpenAI platform and remote/LAN setups — require an HTTP endpoint instead. Rosetta supports the [MCP Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) via the `--http` flag:
+The [MikroTik /app install](#install-on-mikrotik-app) is the easiest way to get an HTTP endpoint. For other setups, rosetta supports the [MCP Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) via `--http`:
 
 ```sh
 rosetta --http                    # http://localhost:8080/mcp
@@ -254,155 +295,47 @@ Then point your MCP client at the URL:
 { "url": "http://localhost:8080/mcp" }
 ```
 
-**Key facts:**
-
-- **Read-only** — the server queries a local SQLite database. It does not store data, accept uploads, or modify anything.
-- **No authentication** — designed for local/trusted-network use. For public exposure, put it behind a reverse proxy (nginx, caddy) with TLS and auth.
-- **TLS built-in** — for direct HTTPS without a proxy: `--tls-cert cert.pem --tls-key key.pem` (or `TLS_CERT_PATH` + `TLS_KEY_PATH` env vars)
-- **Defaults to localhost** — binding to all interfaces (`--host 0.0.0.0`) requires an explicit flag and logs a warning.
-- **Origin validation** — rejects cross-origin requests to prevent DNS rebinding attacks.
-- **Stdio remains default** — `--http` is opt-in. Existing stdio configs are unaffected.
-
-The `PORT`, `HOST`, `TLS_CERT_PATH`, and `TLS_KEY_PATH` environment variables are supported (lower precedence than CLI flags).
+- **Read-only** — queries a local SQLite database, stores nothing.
+- **No authentication** — designed for local/trusted-network use. Use a reverse proxy for public exposure.
+- **TLS built-in** — `--tls-cert cert.pem --tls-key key.pem` for direct HTTPS without a proxy.
+- **Defaults to localhost** — LAN binding (`--host 0.0.0.0`) requires an explicit flag.
 
 ## Container Images
 
-Release CI publishes multi-arch OCI images to:
-
-- Docker Hub: `ammo74/rosetta`
-- GHCR: `ghcr.io/tikoci/rosetta`
-
-Tags per release:
-
-- `${version}` (example: `v0.2.1`)
-- `latest`
-- `sha-<12-char-commit>`
+Multi-arch OCI images (linux/amd64 + linux/arm64) are published with each release:
 
-Container defaults:
-
-- Starts in HTTP mode (`--http`) on `0.0.0.0`
-- Uses `PORT` if set, otherwise 8080
-- Uses HTTPS only when both `TLS_CERT_PATH` and `TLS_KEY_PATH` are set
-
-Examples:
+- `ghcr.io/tikoci/rosetta` (GitHub Container Registry)
+- `ammo74/rosetta` (Docker Hub)
 
 ```sh
 docker run --rm -p 8080:8080 ghcr.io/tikoci/rosetta:latest
 ```
 
-```sh
-docker run --rm -p 8443:8443 \
-  -e PORT=8443 \
-  -e TLS_CERT_PATH=/certs/cert.pem \
-  -e TLS_KEY_PATH=/certs/key.pem \
-  -v "$PWD/certs:/certs:ro" \
-  ghcr.io/tikoci/rosetta:latest
-```
-
-## Building from Source
-
-For contributors or when you have access to the MikroTik HTML documentation export.
-
-### Prerequisites
-
-- [Bun](https://bun.sh/) v1.1+
-- RouterOS HTML documentation export (Confluence space export)
-- Internet access to [tikoci/restraml GitHub Pages](https://tikoci.github.io/restraml/) for command-tree extraction
-
-`make extract` and `make extract-full` fetch `inspect.json` from restraml GitHub Pages by default. You can still pass a local source explicitly:
-
-```sh
-bun run src/extract-commands.ts /path/to/restraml/docs/7.22.1/extra/inspect.json
-bun run src/extract-all-versions.ts /path/to/restraml/docs
-```
-
-### Build
-
-```sh
-git clone https://github.com/tikoci/rosetta.git
-cd rosetta
-bun install
-```
-
-Place the Confluence HTML export in `box/documents-export-<date>/ROS/` and symlink `box/latest` to it:
-
-```sh
-ln -s documents-export-<date> box/latest
-```
-
-Then:
-
-```sh
-make extract       # HTML → properties → commands (single version) → link
-# or
-make extract-full  # Same but with all 46 RouterOS versions
-```
-
-### Development
-
-```sh
-bun test             # Run tests (in-memory SQLite, no DB needed)
-bun run typecheck    # Type check
-make lint            # Biome linter
-bun run src/mcp.ts   # Start MCP server in dev mode
-```
-
-The repo includes `.vscode/mcp.json` — opening the folder in VS Code automatically configures Copilot to use the dev server.
-
-### Creating a Release
-
-The Makefile handles the full release flow — preflight checks, cross-compile, git tag, push, and GitHub Release upload:
-
-```sh
-make release VERSION=v0.1.0
-```
-
-This cross-compiles to macOS (arm64 + x64), Windows (x64), and Linux (x64), creates ZIP archives, compresses the database, tags the commit, and creates a GitHub Release with all artifacts.
-
-The release workflow also publishes OCI images to Docker Hub (`ammo74/rosetta`) and GHCR (`ghcr.io/tikoci/rosetta`) using crane (no Docker daemon required in CI).
-
-## Project Structure
-
-```text
-src/
-├── mcp.ts                  # MCP server (11 tools, stdio + HTTP) + CLI dispatch
-├── setup.ts                # --setup: DB download + MCP client config
-├── query.ts                # NL → FTS5 query planner, BM25 ranking
-├── db.ts                   # SQLite schema, WAL mode, FTS5 triggers
-├── extract-html.ts         # Confluence HTML → pages + callouts
-├── extract-properties.ts   # Property table extraction
-├── extract-commands.ts     # inspect.json → commands (version-aware)
-├── extract-all-versions.ts # Batch extract all 46 versions
-├── extract-devices.ts      # Product matrix CSV → devices table
-├── link-commands.ts        # Command ↔ page mapping
-└── query.test.ts           # Tests (in-memory SQLite fixtures)
-
-scripts/
-└── build-release.ts        # Cross-compile + package releases
-└── container-entrypoint.sh # OCI image runtime entrypoint (HTTP default)
-```
+These are the same images used by the [MikroTik /app install](#install-on-mikrotik-app). Tags: `latest`, version (e.g., `v0.2.1`), and `sha-<commit>`.
 
 ## Data Sources
 
-The database combines three sources of MikroTik data into a single SQLite file with full-text search ([FTS5](https://www.sqlite.org/fts5.html) with [porter stemming](https://www.sqlite.org/fts5.html#porter_tokenizer) and [BM25 ranking](https://www.sqlite.org/fts5.html#the_bm25_function)):
+The database combines multiple MikroTik data sources into a single SQLite file with [FTS5](https://www.sqlite.org/fts5.html) full-text search, [porter stemming](https://www.sqlite.org/fts5.html#porter_tokenizer), and [BM25 ranking](https://www.sqlite.org/fts5.html#the_bm25_function):
 
-- **HTML Documentation** — Confluence space export from help.mikrotik.com (March 2026). The 317 pages are broken out several ways: by section heading, callout boxes (warnings, tips, notes), and property tables (attribute name/type/default/description). This is the richest source — ~515K words of official documentation with direct links back to help.mikrotik.com.
+- **HTML Documentation** — Confluence space export from help.mikrotik.com (March 2026). 317 pages broken into sections, callouts, and property tables (~515K words) with links back to help.mikrotik.com.
 
-- **Command Tree** — `inspect.json` files from [tikoci/restraml](https://github.com/tikoci/restraml), which runs `/console/inspect` requests (`child`, `syntax`, `completion`) against RouterOS CHR under QEMU via GitHub Actions for every version since 7.9. This gives the MCP server structured knowledge of whether a command or argument exists in a particular version (46 versions tracked: 7.9–7.23beta2). The blind spot: these come from CHR with all extra-packages on x86, so commands from packages not available on CHR (like `zerotier` and Wi-Fi driver packages) are missing — the HTML docs cover those.
+- **Command Tree** — `inspect.json` from [tikoci/restraml](https://github.com/tikoci/restraml), generated by running `/console/inspect` against RouterOS CHR under QEMU for every version since 7.9 (46 versions tracked: 7.9–7.23beta2).
 
-- **Product Matrix** — CSV export from mikrotik.com/products/matrix (144 products, 34 columns). Hardware specs, license levels, and pricing — lets the AI answer questions like *"Which routers have L3HW offload and 8+ ports of 48V PoE?"* The CSV requires manual download (the old POST API was removed when the site was redesigned in late 2025).
+- **Product Matrix** — CSV export from mikrotik.com/products/matrix (144 products, 34 columns). Hardware specs, license levels, and pricing.
+
+- **Device Benchmarks** — Ethernet bridging/routing and IPSec throughput test results scraped from individual product pages on mikrotik.com (2,874 measurements across 125 devices; 64/512/1518-byte packets, multiple configurations). Also captures block diagram image URLs for 110 devices.
 
 Documentation covers RouterOS **v7 only** and aligns with the long-term release (~7.22) at export time. v6 had different syntax and major subsystems — answers for v6 are unreliable.
 
 ## Database (Standalone)
 
-The SQLite database is distributed separately from the MCP server code via GitHub Releases:
+The SQLite database is downloadable on its own from [GitHub Releases](https://github.com/tikoci/rosetta/releases):
 
 ```text
 https://github.com/tikoci/rosetta/releases/latest/download/ros-help.db.gz
 ```
 
-The MCP server downloads this automatically on first run (or via `--setup`), but the database is usable on its own with any SQLite client:
+Use it with any SQLite client:
 
 ```sh
 sqlite3 ros-help.db "SELECT title, url FROM pages_fts WHERE pages_fts MATCH 'DHCP lease' ORDER BY rank LIMIT 5;"
@@ -420,8 +353,13 @@ sqlite3 ros-help.db "SELECT title, url FROM pages_fts WHERE pages_fts MATCH 'DHC
 | `command_versions` | 1.67M | Junction table: which command paths exist in which RouterOS versions (7.9–7.23beta2) |
 | `ros_versions` | 46 | Tracked RouterOS versions with channel (stable/development) |
 | `devices` | 144 | MikroTik hardware — CPU, RAM, storage, ports, PoE, wireless, license level, MSRP |
+| `device_test_results` | 2,874 | Ethernet and IPSec throughput benchmarks for 125 devices — packet sizes, modes, Mbps/Kpps |
+
+Each content table has a corresponding FTS5 index (e.g., `pages_fts`, `properties_fts`, `devices_fts`).
+
+## Contributing
 
-Each content table has a corresponding [FTS5](https://www.sqlite.org/fts5.html) index (e.g., `pages_fts`, `properties_fts`, `devices_fts`) using the [porter](https://www.sqlite.org/fts5.html#porter_tokenizer) stemming tokenizer for natural language search with [BM25 ranking](https://www.sqlite.org/fts5.html#the_bm25_function).
+See [CONTRIBUTING.md](CONTRIBUTING.md) for building from source, running tests, development setup, and the release process.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tikoci/rosetta",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "RouterOS documentation as SQLite FTS5 — RAG search + command glossary via MCP",
   "type": "module",
   "license": "MIT",

package/src/db.ts

@@ -250,9 +250,20 @@ export function initDb() {
     sim_slots         INTEGER,
     memory_cards      TEXT,
     usb_type          TEXT,
-    msrp_usd          REAL
+    msrp_usd          REAL,
+    product_url       TEXT,
+    block_diagram_url TEXT
   );`);
 
+  // Migration: add product_url and block_diagram_url columns if missing
+  const devCols = db.prepare("PRAGMA table_info(devices)").all() as Array<{ name: string }>;
+  if (!devCols.some((c) => c.name === "product_url")) {
+    db.run("ALTER TABLE devices ADD COLUMN product_url TEXT;");
+  }
+  if (!devCols.some((c) => c.name === "block_diagram_url")) {
+    db.run("ALTER TABLE devices ADD COLUMN block_diagram_url TEXT;");
+  }
+
   db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS devices_fts USING fts5(
     product_name, product_code, architecture, cpu,
     content=devices,
@@ -275,6 +286,23 @@ export function initDb() {
     VALUES (new.id, new.product_name, new.product_code, new.architecture, new.cpu);
   END;`);
 
+  // -- Device test results (from mikrotik.com product pages) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS device_test_results (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    device_id     INTEGER NOT NULL REFERENCES devices(id),
+    test_type     TEXT NOT NULL,
+    mode          TEXT NOT NULL,
+    configuration TEXT NOT NULL,
+    packet_size   INTEGER NOT NULL,
+    throughput_kpps REAL,
+    throughput_mbps REAL,
+    UNIQUE(device_id, test_type, mode, configuration, packet_size)
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_device_tests_device ON device_test_results(device_id);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_device_tests_type ON device_test_results(test_type);`);
+
   // -- Changelogs (parsed per-entry from MikroTik download server) --
 
   db.run(`CREATE TABLE IF NOT EXISTS changelogs (
@@ -330,6 +358,8 @@ export function getDbStats() {
     commands: count("SELECT COUNT(*) AS c FROM commands"),
     commands_linked: count("SELECT COUNT(*) AS c FROM commands WHERE page_id IS NOT NULL"),
     devices: count("SELECT COUNT(*) AS c FROM devices"),
+    device_test_results: count("SELECT COUNT(*) AS c FROM device_test_results"),
+    devices_with_tests: count("SELECT COUNT(DISTINCT device_id) AS c FROM device_test_results"),
     changelogs: count("SELECT COUNT(*) AS c FROM changelogs"),
     changelog_versions: count("SELECT COUNT(DISTINCT version) AS c FROM changelogs"),
     ros_versions: count("SELECT COUNT(*) AS c FROM ros_versions"),

package/src/extract-test-results.ts

@@ -0,0 +1,359 @@
+/**
+ * extract-test-results.ts — Scrape MikroTik product pages for test results + block diagram URLs.
+ *
+ * Fetches each product page from mikrotik.com and extracts:
+ *   - Ethernet test results (bridging/routing throughput at various packet sizes)
+ *   - IPSec test results (tunnel throughput with various ciphers)
+ *   - Block diagram PNG URL
+ *   - Product page URL slug
+ *
+ * Idempotent: deletes all existing test results, updates device rows.
+ * Requires devices table to be populated first (via extract-devices.ts).
+ *
+ * Usage: bun run src/extract-test-results.ts [--concurrency N] [--delay MS]
+ *
+ * Product page URL slug discovery: fetches the product matrix page to build
+ * a name→slug mapping, then fetches each product page by slug.
+ */
+
+import { parseHTML } from "linkedom";
+import { db, initDb } from "./db.ts";
+
+// ── CLI flags ──
+
+const args = process.argv.slice(2);
+function getFlag(name: string, fallback: number): number {
+  const idx = args.indexOf(`--${name}`);
+  if (idx !== -1 && args[idx + 1]) return Number(args[idx + 1]);
+  return fallback;
+}
+
+const CONCURRENCY = getFlag("concurrency", 4);
+const DELAY_MS = getFlag("delay", 500);
+const PRODUCT_BASE = "https://mikrotik.com/product/";
+
+// ── Types ──
+
+interface TestResultRow {
+  mode: string;
+  configuration: string;
+  packet_size: number;
+  throughput_kpps: number | null;
+  throughput_mbps: number | null;
+}
+
+interface ProductPageData {
+  slug: string;
+  ethernet_results: TestResultRow[];
+  ipsec_results: TestResultRow[];
+  block_diagram_url: string | null;
+}
+
+// ── HTML Parsing ──
+
+/** Decode HTML entities like none to text. */
+function decodeEntities(html: string): string {
+  const { document } = parseHTML("<div></div>");
+  const el = document.createElement("div");
+  el.innerHTML = html;
+  return el.textContent || "";
+}
+
+/** Parse a performance-table element into test result rows. */
+function parsePerformanceTable(table: Element): { testType: string; rows: TestResultRow[] } {
+  const rows: TestResultRow[] = [];
+
+  // Header row: first <tr> in <thead> has [product_code, test_description]
+  const thead = table.querySelector("thead");
+  if (!thead) return { testType: "unknown", rows };
+
+  const headerRows = thead.querySelectorAll("tr");
+  if (headerRows.length < 2) return { testType: "unknown", rows };
+
+  // Determine test type from header description
+  const headerCells = headerRows[0].querySelectorAll("td");
+  const testDesc = headerCells.length >= 2 ? (headerCells[1].textContent || "").trim().toLowerCase() : "";
+  const testType = testDesc.includes("ipsec") ? "ipsec" : "ethernet";
+
+  // Determine packet sizes from the second header row
+  // Structure: [Mode, Configuration, (1518|1400) byte, 512 byte, 64 byte]
+  // The colspan=2 means each size has kpps + Mbps columns
+  const sizeRow = headerRows[1];
+  const sizeCells = sizeRow.querySelectorAll("td");
+  const packetSizes: number[] = [];
+  for (const cell of sizeCells) {
+    const text = (cell.textContent || "").trim();
+    const match = text.match(/^(\d+)\s*byte/i);
+    if (match) packetSizes.push(Number.parseInt(match[1], 10));
+  }
+
+  // If we couldn't find sizes in the header, use defaults
+  if (packetSizes.length === 0) {
+    if (testType === "ipsec") {
+      packetSizes.push(1400, 512, 64);
+    } else {
+      packetSizes.push(1518, 512, 64);
+    }
+  }
+
+  // Parse data rows from <tbody>
+  const tbody = table.querySelector("tbody");
+  if (!tbody) return { testType, rows };
+
+  for (const tr of tbody.querySelectorAll("tr")) {
+    const cells = tr.querySelectorAll("td");
+    if (cells.length < 2) continue;
+
+    const mode = (cells[0].textContent || "").trim();
+    const config = (cells[1].textContent || "").trim();
+
+    // Each packet size has 2 columns: kpps, Mbps
+    for (let i = 0; i < packetSizes.length; i++) {
+      const kppsIdx = 2 + i * 2;
+      const mbpsIdx = 3 + i * 2;
+      if (kppsIdx >= cells.length) break;
+
+      const kpps = Number.parseFloat((cells[kppsIdx].textContent || "").trim());
+      const mbps = mbpsIdx < cells.length
+        ? Number.parseFloat((cells[mbpsIdx].textContent || "").trim())
+        : null;
+
+      rows.push({
+        mode,
+        configuration: config,
+        packet_size: packetSizes[i],
+        throughput_kpps: Number.isNaN(kpps) ? null : kpps,
+        throughput_mbps: mbps !== null && Number.isNaN(mbps) ? null : mbps,
+      });
+    }
+  }
+
+  return { testType, rows };
+}
+
+/** Generate candidate URL slugs for a product.
+ *  MikroTik slugs are wildly inconsistent — some use lowercased names with underscores,
+ *  some use product codes with original casing, and + is sometimes "plus", sometimes dropped.
+ *  Unicode superscripts (², ³) are transliterated to digits.
+ *  We try multiple variants and use the first that returns 200. */
+function generateSlugs(name: string, code: string | null): string[] {
+  const slugs: string[] = [];
+  const seen = new Set<string>();
+  const add = (s: string) => {
+    if (s && !seen.has(s)) {
+      seen.add(s);
+      slugs.push(s);
+    }
+  };
+
+  // Normalize Unicode superscripts to regular digits
+  const norm = (s: string) =>
+    s.replace(/²/g, "2").replace(/³/g, "3").replace(/¹/g, "1");
+
+  const cleanName = norm(name);
+
+  // 1. Lowercased name: + → plus, non-alphanum → _
+  add(cleanName.toLowerCase().replace(/\+/g, "plus").replace(/[^a-z0-9plus]+/g, "_").replace(/^_|_$/g, ""));
+
+  // 2. Lowercased name: drop + entirely
+  add(cleanName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, ""));
+
+  if (code) {
+    const cleanCode = norm(code);
+
+    // 3. Product code as-is (original casing, + → plus, strip other specials)
+    add(cleanCode.replace(/\+/g, "plus").replace(/[^a-zA-Z0-9plus\-]+/g, "").replace(/^-|-$/g, ""));
+
+    // 4. Product code as-is (original casing)
+    add(cleanCode.replace(/[^a-zA-Z0-9\-]+/g, "").replace(/^-|-$/g, ""));
+
+    // 5. Lowercased code: + → plus
+    add(cleanCode.toLowerCase().replace(/\+/g, "plus").replace(/[^a-z0-9plus]+/g, "_").replace(/^_|_$/g, ""));
+
+    // 6. Lowercased code: drop +
+    add(cleanCode.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, ""));
+  }
+
+  return slugs;
+}
+
+/** Fetch and parse a single product page, trying multiple slug candidates. */
+async function fetchProductPage(slugs: string[]): Promise<ProductPageData | null> {
+  for (const slug of slugs) {
+    const url = `${PRODUCT_BASE}${slug}`;
+    try {
+      const resp = await fetch(url);
+      if (resp.ok) {
+        const html = await resp.text();
+        return parseProductHtml(html, slug);
+      }
+      // Don't warn for intermediary attempts — only the last slug matters
+    } catch {
+      // network error, try next slug
+    }
+  }
+  console.warn(`  [404] ${slugs[0]} (tried ${slugs.length} variants)`);
+  return null;
+}
+
+/** Parse product page HTML into structured data. */
+function parseProductHtml(html: string, slug: string): ProductPageData | null {
+
+  const { document } = parseHTML(html);
+
+  // Parse performance tables
+  const tables = document.querySelectorAll("table.performance-table");
+  const ethernet_results: TestResultRow[] = [];
+  const ipsec_results: TestResultRow[] = [];
+
+  for (const table of tables) {
+    const { testType, rows } = parsePerformanceTable(table);
+    if (testType === "ipsec") {
+      ipsec_results.push(...rows);
+    } else {
+      ethernet_results.push(...rows);
+    }
+  }
+
+  // Find block diagram URL
+  let block_diagram_url: string | null = null;
+  const links = document.querySelectorAll("a");
+  for (const a of links) {
+    const text = (a.textContent || "").trim();
+    if (text === "Block Diagram") {
+      const href = a.getAttribute("href");
+      if (href) {
+        block_diagram_url = href.startsWith("http")
+          ? href
+          : `https://cdn.mikrotik.com${href}`;
+      }
+      break;
+    }
+  }
+
+  return { slug, ethernet_results, ipsec_results, block_diagram_url };
+}
+
+/** Sleep helper for rate limiting. */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ── Main ──
+
+initDb();
+
+// Get all devices from DB
+const devices = db.prepare("SELECT id, product_name, product_code FROM devices ORDER BY product_name").all() as Array<{
+  id: number;
+  product_name: string;
+  product_code: string | null;
+}>;
+
+if (devices.length === 0) {
+  console.error("No devices in database. Run extract-devices.ts first.");
+  process.exit(1);
+}
+
+console.log(`Found ${devices.length} devices in database`);
+
+// Build device → candidate slugs mapping
+const deviceSlugs: Array<{ id: number; name: string; slugs: string[] }> = [];
+for (const dev of devices) {
+  const slugs = generateSlugs(dev.product_name, dev.product_code);
+  deviceSlugs.push({ id: dev.id, name: dev.product_name, slugs });
+}
+
+// Idempotent: clear existing test results
+db.run("DELETE FROM device_test_results");
+
+// Prepare statements
+const insertTest = db.prepare(`INSERT OR IGNORE INTO device_test_results (
+  device_id, test_type, mode, configuration, packet_size,
+  throughput_kpps, throughput_mbps
+) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+
+const updateDevice = db.prepare(`UPDATE devices
+  SET product_url = ?, block_diagram_url = ?
+  WHERE id = ?`);
+
+console.log(`Fetching ${deviceSlugs.length} product pages (concurrency=${CONCURRENCY}, delay=${DELAY_MS}ms)...`);
+
+let totalTests = 0;
+let devicesWithTests = 0;
+let devicesWithDiagrams = 0;
+let fetchErrors = 0;
+
+const insertAll = db.transaction(
+  (results: Array<{ deviceId: number; data: ProductPageData | null }>) => {
+    for (const { deviceId, data } of results) {
+      if (!data) {
+        fetchErrors++;
+        continue;
+      }
+
+      // Update device with URL and block diagram
+      updateDevice.run(
+        `https://mikrotik.com/product/${data.slug}`,
+        data.block_diagram_url,
+        deviceId,
+      );
+
+      if (data.block_diagram_url) devicesWithDiagrams++;
+
+      // Insert test results
+      const allResults = [
+        ...data.ethernet_results.map((r) => ({ ...r, test_type: "ethernet" as const })),
+        ...data.ipsec_results.map((r) => ({ ...r, test_type: "ipsec" as const })),
+      ];
+
+      if (allResults.length > 0) devicesWithTests++;
+
+      for (const r of allResults) {
+        insertTest.run(
+          deviceId,
+          r.test_type,
+          r.mode,
+          r.configuration,
+          r.packet_size,
+          r.throughput_kpps,
+          r.throughput_mbps,
+        );
+        totalTests++;
+      }
+    }
+  },
+);
+
+// Fetch all products with rate limiting
+const allResults: Array<{ deviceId: number; data: ProductPageData | null }> = [];
+let processed = 0;
+
+for (let i = 0; i < deviceSlugs.length; i += CONCURRENCY) {
+  const batch = deviceSlugs.slice(i, i + CONCURRENCY);
+  const batchResults = await Promise.all(
+    batch.map(async (dev) => {
+      const data = await fetchProductPage(dev.slugs);
+      return { deviceId: dev.id, data };
+    }),
+  );
+  allResults.push(...batchResults);
+  processed += batch.length;
+
+  const pct = Math.round((processed / deviceSlugs.length) * 100);
+  process.stdout.write(`\r  ${processed}/${deviceSlugs.length} (${pct}%)`);
+
+  if (i + CONCURRENCY < deviceSlugs.length) {
+    await sleep(DELAY_MS);
+  }
+}
+console.log(""); // newline after progress
+
+// Insert all results in one transaction
+insertAll(allResults);
+
+console.log(`Test results: ${totalTests} rows for ${devicesWithTests} devices`);
+console.log(`Block diagrams: ${devicesWithDiagrams} devices`);
+if (fetchErrors > 0) {
+  console.warn(`Fetch errors: ${fetchErrors} products`);
+}

package/src/mcp.ts

@@ -38,6 +38,12 @@ function getArg(name: string): string | undefined {
   return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
 }
 
+/** Format a clickable terminal hyperlink using OSC 8 escape sequences.
+ *  Falls back to plain URL in terminals that don't support OSC 8. */
+function link(url: string, display?: string): string {
+  return `\x1b]8;;${url}\x07${display ?? url}\x1b]8;;\x07`;
+}
+
 if (args.includes("--version") || args.includes("-v")) {
   console.log(`rosetta ${RESOLVED_VERSION}`);
   process.exit(0);
@@ -64,8 +70,10 @@ if (args.includes("--help") || args.includes("-h")) {
   console.log("  DB_PATH  Absolute path to ros-help.db (optional)");
   console.log("  PORT     HTTP listen port (lower precedence than --port)");
   console.log("  HOST     HTTP bind address (lower precedence than --host)");
-  console.log("  TLS_CERT_PATH  TLS certificate path (lower precedence than --tls-cert)");
-  console.log("  TLS_KEY_PATH   TLS private key path (lower precedence than --tls-key)");
+  console.log();
+  console.log(`Quick start:  bunx @tikoci/rosetta --setup`);
+  console.log(`Project:      ${link("https://github.com/tikoci/rosetta")}`);
+  console.log(`Docs:         ${link("https://help.mikrotik.com/docs/spaces/ROS/overview", "help.mikrotik.com")}`);
   process.exit(0);
 }
 
@@ -630,16 +638,26 @@ Examples:
 server.registerTool(
   "routeros_device_lookup",
   {
-    description: `Look up MikroTik hardware specs or search for devices matching criteria.
+    description: `Look up MikroTik hardware specs, performance benchmarks, or search for devices matching criteria.
 
-144 products from mikrotik.com/products/matrix (March 2026). Returns hardware specs
-including CPU, RAM, storage, ports, PoE, wireless, license level, and price.
+144 products from mikrotik.com (March 2026). Returns hardware specs, official test results,
+block diagram URLs, and pricing.
 
 **How it works:**
-- If query matches a product name or code exactly → returns full specs for that device
-- Otherwise → FTS search + optional structured filters → returns matching devices
+- If query matches a product name or code exactly → returns full specs + test results + block diagram
+- Otherwise → FTS search + optional structured filters → returns matching devices (compact)
 - Filters can be used alone (no query) to find devices by capability
 
+**Test results** (from mikrotik.com per-product pages):
+- Ethernet: bridging/routing throughput at 64/512/1518 byte packets (kpps + Mbps)
+- IPSec: tunnel throughput with various AES/SHA configurations
+- Key metric: "Routing 25 ip filter rules @ 512 byte" is a common routing performance gauge
+- Devices with L3HW offload show additional hardware-accelerated routing rows
+- Included automatically for exact/single-device lookups — no extra call needed
+
+**Block diagram**: internal switch/CPU/PHY architecture diagram URL (PNG).
+Shows bus topology and per-port bandwidth limits — useful for understanding SoC bottlenecks.
+
 **License levels** determine feature availability:
 - L3: CPE/home (no routing protocols, limited queues)
 - L4: standard (OSPF, BGP, all firewall features)

package/src/query.test.ts

@@ -87,13 +87,15 @@ beforeAll(() => {
      license_level, operating_system, ram, ram_mb, storage, storage_mb,
      poe_in, poe_out, wireless_24_chains, wireless_5_chains,
      eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
-     eth_multigig, usb_ports, sim_slots, msrp_usd)
+     eth_multigig, usb_ports, sim_slots, msrp_usd,
+     product_url, block_diagram_url)
     VALUES
     ('hAP ax3', 'C53UiG+5HPaxD2HPaxD', 'ARM 64bit', 'IPQ-6010', 4, 'auto (864 - 1800) MHz',
      4, 'RouterOS v7', '1 GB', 1024, '128 MB', 128,
      '802.3af/at', NULL, 2, 2,
      NULL, 4, 1, NULL, NULL,
-     NULL, 1, NULL, 139.00)`);
+     NULL, 1, NULL, 139.00,
+     'https://mikrotik.com/product/hap_ax3', 'https://cdn.mikrotik.com/web-assets/product_files/hap_ax3_123.png')`);
 
   db.run(`INSERT INTO devices
     (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
@@ -161,6 +163,17 @@ beforeAll(() => {
      NULL, 13, NULL, NULL, NULL,
      NULL, NULL, NULL, 369.00)`);
 
+  // Device test results fixtures (hAP ax3 = id 1)
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ethernet', 'Routing', '25 ip filter rules', 512, 755.9, 3096.2)`);
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ethernet', 'Routing', 'none (fast path)', 512, 2332.0, 9551.9)`);
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ipsec', 'Single tunnel', 'AES-128-CBC + SHA1', 1400, 120.9, 1354.1)`);
+
   // Page 3: a "large" page with sections for TOC testing
   // Text is ~200 chars to keep fixture small, but we'll use max_length=50 to trigger truncation
   db.run(`INSERT INTO pages
@@ -783,6 +796,37 @@ describe("searchDevices", () => {
     const res = searchDevices("");
     expect(res.results).toHaveLength(0);
   });
+
+  test("exact match includes test_results", () => {
+    const res = searchDevices("hAP ax3");
+    expect(res.mode).toBe("exact");
+    expect(res.results).toHaveLength(1);
+    const dev = res.results[0];
+    expect(dev.test_results).toBeDefined();
+    expect(dev.test_results!.length).toBe(3);
+    expect(dev.test_results!.some((t) => t.test_type === "ethernet")).toBe(true);
+    expect(dev.test_results!.some((t) => t.test_type === "ipsec")).toBe(true);
+  });
+
+  test("LIKE match with ≤5 results includes test_results", () => {
+    const res = searchDevices("RB1100");
+    expect(res.mode).toBe("like");
+    expect(res.results.length).toBeLessThanOrEqual(5);
+    // RB1100 devices have no test results, but the field should still be populated (empty array)
+    expect(res.results.every((d) => Array.isArray(d.test_results))).toBe(true);
+  });
+
+  test("exact match includes product_url and block_diagram_url", () => {
+    const res = searchDevices("hAP ax3");
+    expect(res.results[0].product_url).toBe("https://mikrotik.com/product/hap_ax3");
+    expect(res.results[0].block_diagram_url).toContain("cdn.mikrotik.com");
+  });
+
+  test("devices without product_url return null", () => {
+    const res = searchDevices("CCR2216-1G-12XS-2XQ");
+    expect(res.results[0].product_url).toBeNull();
+    expect(res.results[0].block_diagram_url).toBeNull();
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -943,7 +987,7 @@ describe("schema", () => {
     const expected = [
       "pages", "properties", "callouts", "sections",
       "commands", "command_versions", "ros_versions",
-      "devices", "changelogs", "schema_migrations",
+      "devices", "device_test_results", "changelogs", "schema_migrations",
     ];
     for (const table of expected) {
       expect(names).toContain(table);

package/src/query.ts

@@ -669,6 +669,15 @@ export function browseCommandsAtVersion(
 
 // ── Device lookup and search ──
 
+export type DeviceTestResult = {
+  test_type: string;
+  mode: string;
+  configuration: string;
+  packet_size: number;
+  throughput_kpps: number | null;
+  throughput_mbps: number | null;
+};
+
 export type DeviceResult = {
   id: number;
   product_name: string;
@@ -698,6 +707,9 @@ export type DeviceResult = {
   usb_ports: number | null;
   sim_slots: number | null;
   msrp_usd: number | null;
+  product_url: string | null;
+  block_diagram_url: string | null;
+  test_results?: DeviceTestResult[];
 };
 
 export type DeviceFilters = {
@@ -715,9 +727,29 @@ const DEVICE_SELECT = `SELECT id, product_name, product_code, architecture, cpu,
     ram, ram_mb, storage, storage_mb, dimensions, poe_in, poe_out,
     max_power_w, wireless_24_chains, wireless_5_chains,
     eth_fast, eth_gigabit, eth_2500, sfp_ports, sfp_plus_ports,
-    eth_multigig, usb_ports, sim_slots, msrp_usd
+    eth_multigig, usb_ports, sim_slots, msrp_usd,
+    product_url, block_diagram_url
   FROM devices`;
 
+/** Get test results for a device by ID. */
+function getDeviceTestResults(deviceId: number): DeviceTestResult[] {
+  return db.prepare(
+    `SELECT test_type, mode, configuration, packet_size,
+            throughput_kpps, throughput_mbps
+     FROM device_test_results
+     WHERE device_id = ?
+     ORDER BY test_type, mode, configuration, packet_size DESC`
+  ).all(deviceId) as DeviceTestResult[];
+}
+
+/** Attach test results to device results (for single/exact lookups). */
+function attachTestResults(devices: DeviceResult[]): DeviceResult[] {
+  for (const dev of devices) {
+    dev.test_results = getDeviceTestResults(dev.id);
+  }
+  return devices;
+}
+
 /** Build FTS5 query for devices — appends prefix '*' to every term.
  *  Model numbers like "RB1100" need prefix matching to find "RB1100AHx4".
  *  No compound term handling (not relevant for device names). */
@@ -739,7 +771,7 @@ export function searchDevices(
       .prepare(`${DEVICE_SELECT} WHERE product_name = ? COLLATE NOCASE OR product_code = ? COLLATE NOCASE`)
       .all(query, query) as DeviceResult[];
     if (exact.length > 0) {
-      return { results: exact, mode: "exact", total: exact.length };
+      return { results: attachTestResults(exact), mode: "exact", total: exact.length };
     }
   }
 
@@ -760,6 +792,8 @@ export function searchDevices(
       const likeSql = `${DEVICE_SELECT} d WHERE ${likeConditions.join(" AND ")} ORDER BY d.product_name LIMIT ?`;
       const likeResults = db.prepare(likeSql).all(...likeParams, limit) as DeviceResult[];
       if (likeResults.length > 0) {
+        // Attach test results for small result sets (likely specific device lookups)
+        if (likeResults.length <= 5) attachTestResults(likeResults);
         return { results: likeResults, mode: "like", total: likeResults.length };
       }
     }
@@ -807,7 +841,8 @@ export function searchDevices(
           d.ram, d.ram_mb, d.storage, d.storage_mb, d.dimensions, d.poe_in, d.poe_out,
           d.max_power_w, d.wireless_24_chains, d.wireless_5_chains,
           d.eth_fast, d.eth_gigabit, d.eth_2500, d.sfp_ports, d.sfp_plus_ports,
-          d.eth_multigig, d.usb_ports, d.sim_slots, d.msrp_usd
+          d.eth_multigig, d.usb_ports, d.sim_slots, d.msrp_usd,
+          d.product_url, d.block_diagram_url
         FROM devices_fts fts
         JOIN devices d ON d.id = fts.rowid
         WHERE devices_fts MATCH ?${filterWhere}

package/src/release.test.ts

@@ -238,6 +238,7 @@ describe("release.yml", () => {
     expect(src).toContain("extract-properties.ts");
     expect(src).toContain("extract-commands.ts");
     expect(src).toContain("extract-devices.ts");
+    expect(src).toContain("extract-test-results.ts");
     expect(src).toContain("extract-changelogs.ts");
     expect(src).toContain("link-commands.ts");
   });

package/src/setup.ts

@@ -65,6 +65,7 @@ export async function runSetup(force = false) {
   const dbPath = resolveDbPath(import.meta.dirname);
 
   console.log(`rosetta ${RELEASE_VERSION}`);
+  console.log(`  ${link("https://github.com/tikoci/rosetta")}`);
   console.log();
 
   // ── Download DB if needed ──
@@ -301,8 +302,29 @@ function printHttpConfig(startCmd: string) {
   console.log("  For LAN access, replace localhost with the server's IP address.");
   console.log("  Use a reverse proxy (nginx, caddy) for production HTTPS.");
   console.log();
+
+  printMikroTikConfig();
+}
+
+/** Format a clickable terminal hyperlink using OSC 8 escape sequences. */
+function link(url: string, display?: string): string {
+  return `\x1b]8;;${url}\x07${display ?? url}\x1b]8;;\x07`;
 }
 
+function printMikroTikConfig() {
+  console.log("─".repeat(60));
+  console.log("MikroTik /app container (RouterOS 7.22+, x86 or ARM64):");
+  console.log("─".repeat(60));
+  console.log();
+  console.log("  Run directly on your MikroTik router — any MCP client on");
+  console.log("  the network can connect to the URL shown in the router UI.");
+  console.log();
+  console.log("  Requires: container package + device-mode enabled.");
+  console.log(`  See: ${link("https://github.com/tikoci/rosetta#install-on-mikrotik-app", "README — Install on MikroTik")}`);
+  console.log();
+}
+
+
 // Run directly
 if (import.meta.main) {
   const force = process.argv.includes("--force");