# io.github.wygogogo19/robotbase-dev (remote · dev.robotbase.cc)

Agent MCP: 18 tools — GitHub/HF/npm/PyPI/HN trends plus 17 web tools for coding agents.

- Trust score: 68/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `dev.robotbase.cc`: 68/100 (this document), [markdown](https://verifymcp.io/servers/wygogogo19-robotbase-dev/dev.md), [page](https://verifymcp.io/servers/wygogogo19-robotbase-dev/dev)

## Channel facts

- Endpoint: `https://dev.robotbase.cc/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.32.3`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 405, which proves neither a plaintext path nor enforcement.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 65/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4448 tokens (~247/item across 18 items; 18 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 43/100
  - Stability observed for 13 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 96% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "web_monitor_delete" implies "delete" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 19 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### How do I install the io.github.wygogogo19/robotbase-dev MCP server?

io.github.wygogogo19/robotbase-dev is a hosted endpoint at https://dev.robotbase.cc/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http wygogogo19-robotbase-dev 'https://dev.robotbase.cc/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "wygogogo19-robotbase-dev": {
      "url": "https://dev.robotbase.cc/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "wygogogo19-robotbase-dev": {
      "type": "http",
      "url": "https://dev.robotbase.cc/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.wygogogo19-robotbase-dev]
url = "https://dev.robotbase.cc/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "wygogogo19-robotbase-dev": {
      "type": "remote",
      "url": "https://dev.robotbase.cc/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add wygogogo19-robotbase-dev --url 'https://dev.robotbase.cc/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  wygogogo19-robotbase-dev:
    url: "https://dev.robotbase.cc/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "wygogogo19-robotbase-dev": {
      "Transport": "http",
      "Url": "https://dev.robotbase.cc/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add wygogogo19-robotbase-dev -t streamable-http -u 'https://dev.robotbase.cc/mcp'
```

### Other

```json
{
  "mcpServers": {
    "wygogogo19-robotbase-dev": {
      "type": "http",
      "url": "https://dev.robotbase.cc/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 68, +50)

- [security improvement] Authorization: unverified → partial
- [security improvement] Injection markers: unverified → pass
- [security improvement] Transport: fail → pass
- [security] Tool “web_search” rewrote its description, which is the text the model reads
- [functional regression] MCP protocol: unverified → fail
- [functional improvement] Endpoint reachability: not serving MCP → reachable
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Stability: unverified → 0.43
- [functional] Server version: 0.32.6 → 0.33.0

### 2026-11-04 (score 18, −49)

- [security regression] Endpoint reachability: reachable → not serving MCP
- [security regression] Stability: 0.37 → unverified
- [security regression] Authorization: partial → unverified
- [security regression] Tool safety: pass → unverified
- [security regression] Transport: pass → fail
- [functional regression] Capabilities: fail → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified

### 2026-11-03 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-31 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-29 (score 65, +1)

- [functional] Server version: 0.32.2 → 0.32.6

### 2026-10-27 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-25 (score 63, +1)

- [functional] Server version: 0.32.0 → 0.32.2

### 2026-10-24 (score 62, 0)

- [functional improvement] Stability: unverified → 0.03

## MCP tools (18)

### `web_search` (~368 tokens)

Web Search

Search the live web and get ranked results with title, URL, snippet and published date. When to use: an agent needs current facts, news or links that are not on chain - 'what is the BTC fee market saying today', 'recent Zcash governance proposals', 'find the docs page for X'. Use it before web_fetch, then fetch the one URL that looks authoritative. Do not use: for on-chain facts (use the BTC/LTC/ETH/XMR/ZEC/TRON tools) or for content inside a CyberLibrary book (use cyberlibrary_fulltext_search). Provider: self-hosted SearXNG (Bing/Baidu/360/Sogou/Yandex/Marginalia) first, then Serper, Tavily and cn.bing RSS as automatic fallbacks. Returns: {query, count, results:[{title,url,snippet,published}], provider (serper|tavily|bing_rss), cached, took_ms, _metering}. Results may be cached for up to 10 minutes; a cached result still counts as one call against the free allowance. Metered: all web tools share 100 free calls/day per IP (separate from the risk/library allowance), then 1 credit per call over x402 - there is no API key; the 402 answer carries accepts[]. max count is 10.

Input parameters:

- `count` (integer): Number of results to return, 1-10. Default 5.
- `freshness` (string): Optional freshness filter.
- `lang` (string): Optional language preference, e.g. zh-cn or en.
- `query` (string, required): Search query (1-200 characters).
- `site` (string): Optional: restrict results to one domain, e.g. github.com.

### `web_fetch` (~361 tokens)

Web Fetch

Fetch one public web page and return its readable text as clean markdown or plain text, with navigation, scripts, headers and footers stripped. When to use: you have a specific URL (from web_search or the user) and need what the page actually says - 'read this article', 'summarise this docs page', 'turn this URL into markdown'. Do not use: to crawl or mirror a site, to fetch a page behind a login or paywall, to read API/RPC endpoints, or for book text inside CyberLibrary (use cyberlibrary_get_chapter). Returns: {url, final_url, status, title, content, chars, truncated, fetched_at, source (direct|provider), cached, took_ms, _metering}. The response is capped at 12000 characters per call; raise max_chars (up to 20000) when you need more. Reads one public URL only, respects robots.txt, and does not bypass login or paywall. Direct fetch is tried first; pages blocked from this node are fetched through a provider and marked source=provider. Metered: all web tools share 100 free calls/day per IP (separate from the risk/library allowance), then 1 credit per call over x402 - there is no API key; the 402 answer carries accepts[].

Input parameters:

- `format` (string): Output format. Default markdown.
- `max_chars` (integer): Truncate the returned content to this many characters (2000-20000). Default 8000.
- `ocr` (boolean): Force OCR on scanned PDFs/images (auto-detected by default; set false to skip).
- `url` (string, required): The http(s) URL to read (max 2048 chars).

### `web_screenshot` (~258 tokens)

Web Screenshot

Capture a screenshot of one public web page as an image (JPEG) plus metadata. When to use: visual layout matters - a dashboard, chart, UI state, or 'what does this page look like'. Do not use: to read text (use web_fetch), for pages behind a login or paywall, or for bulk capture. Returns: image content (image/jpeg) plus {url, final_url, title, width, height, bytes, engine, elapsed_ms, _metering}. Rendered by a real Chromium browser, robots.txt-respecting, SSRF-guarded, max 3MB per image. Metered: shares the web free bucket (100 calls/day per IP shared by all twelve web tools), then 2 credits per call over x402 - there is no API key; the 402 answer carries accepts[].

Input parameters:

- `full_page` (boolean): Capture the whole page instead of the viewport. Default false.
- `height` (integer): Viewport height 240-1200. Default 800.
- `url` (string, required): The http(s) URL to capture (max 2048 chars).
- `width` (integer): Viewport width 320-1920. Default 1280.

### `web_map` (~177 tokens)

Web Map

Discover the URLs of one site - sitemap first, then same-host links from the homepage. When to use: you need the list of pages a site exposes before fetching a few of them. Do not use: as a crawler (max 50 URLs, no page content) or to bypass robots.txt. Returns: {url, final_url, count, urls:[{url,source}], cached, took_ms, _metering}. Metered: shares the web free bucket (100 calls/day per IP shared by all web tools), then 1 credit per call over x402 - there is no API key; the 402 answer carries accepts[].

Input parameters:

- `limit` (integer): Max URLs to return, 1-50. Default 50.
- `url` (string, required): Site root or page URL (max 2048 chars).

### `web_fetch_batch` (~260 tokens)

Web Fetch Batch

Fetch up to 5 public URLs in one call and return each page's title, engine and a short snippet (first ~1200 characters), so an agent can triage several links quickly. When to use: search returned several candidate pages and you want a first pass over all of them; then call web_fetch on the ones worth reading in full. Do not use: when you need the complete text of a page (use web_fetch), or to crawl a site (use web_map). Returns: {ok, count, ok_count, results:[{url, ok, final_url, status, title, engine, chars, snippet, error?}], took_ms, _metering}. Partial failures do not fail the whole call. Metered: counts one call per URL against the shared web free bucket (50 URLs/day per IP together with web_fetch), then 1 credit per URL over x402 - max 5 URLs per call, no API key.

Input parameters:

- `format` (string): Snippet format. Default markdown.
- `max_chars` (integer): Snippet length per page, 200-2000. Default 1200.
- `urls` (array, required): 1-5 http(s) URLs to fetch in one call.

### `web_feed` (~195 tokens)

Web Feed

Read an RSS or Atom feed and return its latest items. When to use: the user wants the latest posts/news from a site that publishes a feed, or you found a feed URL and want headlines plus links. Do not use: to read article text (use web_fetch) or to discover a site's URLs (use web_map). Returns: {ok, url, final_url, title, count, items:[{title, link, published, summary}], cached, took_ms, _metering}. Summary is HTML-stripped and capped at 500 characters. Metered: shares the web free bucket (100 calls/day per IP shared by all web tools), then 1 credit per call over x402 - there is no API key.

Input parameters:

- `limit` (integer): Max items to return, 1-20. Default 10.
- `url` (string, required): RSS/Atom feed URL (max 2048 chars).

### `web_metadata` (~180 tokens)

Web Metadata

Extract a page's structured metadata: Open Graph, Twitter cards, canonical URL, language and JSON-LD. When to use: you need the title/description/author/image of a page, or JSON-LD structured data for a product/article, without reading the whole page. Do not use: when you need the page text (use web_fetch) or a screenshot (use web_screenshot). Returns: {ok, url, final_url, title, description, image, site_name, type, canonical, lang, jsonld[], cached, took_ms, _metering}. Metered: shares the web free bucket (100 calls/day per IP shared by all web tools), then 1 credit per call over x402 - there is no API key.

Input parameters:

- `url` (string, required): The http(s) page URL (max 2048 chars).

### `web_crawl` (~255 tokens)

Web Crawl

Crawl one site's same-host pages starting from a URL (depth 1-2, at most 20 pages) and return each page's title, URL and readable text. When to use: you need several pages from one site (docs section, news index, product list) and web_map alone is not enough. Do not use: to mirror a whole site (hard cap 20 pages, same host), or for one page (web_fetch). Returns: {ok, url, final_url, count, pages:[{url, title, status, chars, content}], cached, took_ms, _metering}. Respects robots.txt and SSRF guards; partial page failures are skipped. Metered: shares the web free bucket (100 calls/day per IP shared by all web tools), then 3 credits per call over x402 - no API key.

Input parameters:

- `depth` (integer): Link depth 1-2. Default 2.
- `max_chars` (integer): Per-page content cap 200-4000. Default 1000.
- `max_pages` (integer): Max pages 1-20. Default 20.
- `url` (string, required): Start URL (same host is crawled).

### `web_extract` (~197 tokens)

Web Extract

Extract structured data from one public page: tables (headers + rows), JSON-LD blocks, and Open Graph/Twitter/canonical/language metadata. When to use: the page has tables or schema.org JSON-LD you need as data, without an LLM. Do not use: when you only need the page text (web_fetch) or a screenshot (web_screenshot). Returns: {ok, url, final_url, title, meta:{description,image,site_name,type,canonical,lang}, jsonld[], tables:[{caption,headers,rows}], links? , cached, took_ms, _metering}. Metered: shares the web free bucket (100 calls/day per IP shared by all web tools), then 1 credit per call over x402.

Input parameters:

- `include_links` (boolean): Also return same-host links (max 100). Default false.
- `url` (string, required): The http(s) page URL.

### `web_act` (~287 tokens)

Web Act

Drive a real Chromium browser on one public page: click, type, press keys, scroll, wait for selectors, then return the resulting text (and optionally a screenshot and JSON XHR responses). When to use: the page needs interaction before its content appears (cookie banners, tabs, 'load more', form submit) and web_fetch/web_crawl cannot see it. Do not use: for plain reading (web_fetch) or bulk crawling (web_crawl); no login/paywall bypass. Returns: {ok, url, final_url, title, markdown, chars, elapsed_ms, screenshot?, xhr?, took_ms, _metering}. Max 10 actions; screenshot returns MCP image content. Metered: shares the web free bucket (100 calls/day per IP shared by all web tools), then 3 credits per call over x402.

Input parameters:

- `actions` (array, required): Actions: {type: click|type|press|scroll|wait_for|wait_ms, ...}
- `full_page` (boolean): Full-page screenshot. Default false.
- `include_xhr` (boolean): Return JSON XHR responses captured while acting. Default false.
- `max_chars` (integer): Text cap 1000-20000. Default 20000.
- `screenshot` (boolean): Return a JPEG screenshot. Default false.
- `url` (string, required): The http(s) page URL.

### `web_crawl_async` (~251 tokens)

Web Crawl Async

Submit a same-host crawl as an asynchronous job and return a job_id immediately. When to use: you need more than a couple of pages and cannot hold a long HTTP request; submit here, then poll web_crawl_job until status is done, failed or cancelled. Do not use: for one page (web_fetch) or when you need the result in this call (web_crawl). Returns: {ok, job_id, status, url, depth, max_pages, max_chars, idempotent, poll_with}. Pass idempotency_key to retry safely (24h window returns the same job). Metered: shares the web free bucket (100 calls/day per IP), then 3 credits per submit over x402.

Input parameters:

- `depth` (integer): Link depth 1-2. Default 2.
- `idempotency_key` (string): Optional; retries within 24h return the same job.
- `max_chars` (integer): Per-page content cap 200-4000. Default 1000.
- `max_pages` (integer): Max pages 1-20. Default 20.
- `url` (string, required): Start URL (same host is crawled).

### `web_crawl_job` (~176 tokens)

Web Crawl Job

Check or cancel an asynchronous crawl job created by web_crawl_async. When to use: after web_crawl_async, poll with action=status until status is done/failed/cancelled; use action=cancel to stop a running job. Do not use: to start a crawl (web_crawl_async) or for a quick one-page read (web_fetch). Returns status: {ok, job_id, status: queued|running|done|failed|cancelled, progress:{pages_done,max_pages}, created_at, updated_at, result?, error?}. Free (not metered); rate-limited. Done result uses the same shape as web_crawl.

Input parameters:

- `action` (string): Poll status (default) or cancel the job.
- `job_id` (string, required): job_id returned by web_crawl_async.

### `web_extract_schema` (~242 tokens)

Web Extract Schema

Extract a page's structured data into a named schema's common fields (no LLM): article, product, event, faq, recipe, course, organization, local_business, breadcrumb, dataset or job_posting. When to use: you need fields (title/author/date, price/currency/availability, event dates, FAQ Q&A, recipe ingredients, org address) rather than raw markdown or tables. Do not use: to get every JSON-LD block verbatim (web_metadata/web_extract) or to read text (web_fetch). Returns: {ok, url, final_url, schema, requested_schema, detected_types, matched, fields:{...}, sources:[jsonld|meta], jsonld_count, tables_count, took_ms, cached, _metering}. If no matching JSON-LD exists it falls back to Open Graph/meta fields and matched=false. Metered: shares the web free bucket (100 calls/day per IP), then 1 credit per call over x402.

Input parameters:

- `schema` (string): Target schema; auto detects from JSON-LD types. Default auto.
- `url` (string, required): The http(s) page URL.

### `web_diff` (~256 tokens)

Web Diff

Fetch a page now and compare it with the previous snapshot of the same URL, returning whether it changed and a unified diff (no LLM). When to use: monitoring a page for updates - prices, docs, policy pages, SEO titles/meta; first call stores the baseline, later calls return added/removed lines. Do not use: for one-off reading (web_fetch) or structured fields (web_extract_schema). Returns: {ok, url, baseline, changed, diff, added_lines, removed_lines, previous_ts, current_ts, title, hash, chars, fetched_cached, took_ms, _metering}. fresh=true (default) adds a cache-busting query to bypass the 6h page cache; pass fresh=false to compare cached content. Snapshots are kept per URL in SQLite (latest only). Metered: shares the web free bucket (100 calls/day per IP), then 1 credit per call over x402.

Input parameters:

- `fresh` (boolean): Bypass the page cache with a cache-busting query. Default true.
- `max_chars` (integer): Compare at most this many chars (500-12000). Default 4000.
- `url` (string, required): The http(s) page URL.

### `web_monitor_set` (~362 tokens)

Web Monitor Set

Create a scheduled change monitor for one public URL: the server re-fetches the page on an interval, stores a new snapshot and records a diff event whenever the readable text changes. When to use: the user wants to be told when a page changes (price, docs, policy page, job post, release notes) and cannot poll it themselves; also for handing off 'watch this for me'. Do not use: for a single comparison right now (web_diff) or when you only need the page today (web_fetch). Returns: {ok, monitor_id, url, status:active, interval_minutes, next_check_ts, webhook_enabled, webhook_secret?, webhook_signature?, hint}. The first check runs within ~60s to store the baseline; later changes show up in web_monitor_list.recent_events and, if requested, are POSTed to webhook_url. Webhook: https only, no redirects, 8s timeout, up to 2 retries (30s/120s); body JSON {monitor_id,url,ts,changed,added_lines,removed_lines,title,diff,event_id}; verify header 'X-RobotBase-Signature: sha256=<hex HMAC-SHA256 of the raw body using webhook_secret>'. Limits: 15-1440 minutes; max 5 monitors per IP; monitors expire after 7 days. Metered: 1 credit (shares the web free bucket of 100 calls/day per IP).

Input parameters:

- `interval_minutes` (integer): Check interval 15-1440 minutes. Default 60.
- `url` (string, required): The http(s) URL to watch (max 2048 chars).
- `webhook_url` (string): Optional https endpoint notified on each change (HMAC-signed).

### `web_monitor_list` (~237 tokens)

Web Monitor List

List the scheduled change monitors owned by the calling IP, with latest/next check time, last title or error, and the 5 most recent change events. When to use: after web_monitor_set, poll this instead of re-fetching the page; or to show the user what is currently being watched. Do not use: to create a monitor (web_monitor_set) or to compare one page now (web_diff). Returns: {ok, count, monitors:[{monitor_id,url,interval_minutes,active,created_ts,last_check_ts,next_check_ts,last_title,last_error,webhook_enabled,events_total,recent_events}], note}. Pass monitor_id to get that one monitor plus last_event.diff (the most recent detected change, up to 4000 chars) so you can read what changed without a webhook. Free (not metered); rate-limited to 20 calls/min per IP.

Input parameters:

- `include_diff` (boolean): With monitor_id, include the latest unified diff. Default true.
- `monitor_id` (string): Optional: return this monitor (owned by the calling IP) plus its most recent change diff.

### `web_monitor_delete` (~132 tokens)

Web Monitor Delete

Delete one scheduled change monitor owned by the calling IP (its event history is removed too). When to use: the user no longer needs to watch a page, or the per-IP monitor limit was reached. Do not use: to pause a monitor temporarily - there is no pause; delete and re-create. Returns: {ok, deleted, monitor_id, note}; unknown or foreign ids return {ok:false,error:'monitor_not_found'} and delete nothing. Free (not metered); rate-limited to 20 calls/min per IP.

Input parameters:

- `monitor_id` (string, required): monitor_id returned by web_monitor_set.

### `dev_trending` (~121 tokens)

Dev Trending

Developer ecosystem trends: GitHub repos, Hugging Face models, npm packages, PyPI stats and Hacker News. When to use: choosing a library/model, seeing what developers are adopting, checking package health. Do not use: for general web search (web_search) or social hot lists (social_hot). Returns: {ecosystem, items:[{name, metric, value, url, description, source}], errors}.

Input parameters:

- `ecosystem` (string)
- `limit` (integer)
- `query` (string): Optional package/repo search term.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/wygogogo19-robotbase-dev/dev#diagnostics

## Score history

- 2026-11-05: 68
- 2026-11-04: 18
- 2026-11-03: 67
- 2026-11-02: 66
- 2026-11-01: 66
- 2026-10-31: 66
- 2026-10-30: 65
- 2026-10-29: 65
- 2026-10-28: 64
- 2026-10-27: 64
- 2026-10-26: 63
- 2026-10-25: 63
- 2026-10-24: 62
- 2026-10-23: 62

## Common questions

### What is the io.github.wygogogo19/robotbase-dev MCP server?

io.github.wygogogo19/robotbase-dev is an MCP server listed in the public MCP registry as io.github.wygogogo19/robotbase-dev. Agent MCP: 18 tools, GitHub/HF/npm/PyPI/HN trends plus 17 web tools for coding agents. This page covers its hosted endpoint (https://dev.robotbase.cc/mcp).

### Is the io.github.wygogogo19/robotbase-dev MCP server safe to use?

io.github.wygogogo19/robotbase-dev scores 68 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.wygogogo19/robotbase-dev MCP server expose?

io.github.wygogogo19/robotbase-dev exposes 18 tools: web_search, web_fetch, web_screenshot, web_map, web_fetch_batch, and 13 more. Their descriptions and schemas cost roughly 4,315 tokens of context every time the server is loaded.

### Does the io.github.wygogogo19/robotbase-dev MCP server require authentication?

No. We connected to io.github.wygogogo19/robotbase-dev without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the io.github.wygogogo19/robotbase-dev MCP server still maintained?

io.github.wygogogo19/robotbase-dev is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://dev.robotbase.cc/mcp
- Repository: https://github.com/wygogogo19/robotbase-dev
- Website: https://dev.robotbase.cc/mcp
- Changelog RSS feed: https://verifymcp.io/servers/wygogogo19-robotbase-dev/dev.xml
- Changelog JSON feed: https://verifymcp.io/servers/wygogogo19-robotbase-dev/dev.json
- HTML version of this page: https://verifymcp.io/servers/wygogogo19-robotbase-dev/dev