WET - Web Extended Toolkit MCP Server
Enables searching academic papers on arXiv.
Provides web search via the Brave search engine.
Bypasses Cloudflare anti-bot protection to scrape content from protected sites.
Provides web search via DuckDuckGo.
Provides web search via Google.
Syncs indexed documentation across machines using Google Drive.
Enables searching academic papers on Google Scholar.
Bypasses Medium's restrictions to extract content.
Allows using OpenAI models for embeddings, reranking, and LLM-powered synthesis.
Enables searching academic papers on PubMed.
Provides metasearch web search via an embedded SearXNG instance.
Enables searching academic papers on Semantic Scholar.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@WET - Web Extended Toolkit MCP Serversearch for recent web scraping tutorials"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
WET - Web Extended Toolkit MCP Server
mcp-name: io.github.n24q02m/wet-mcp
Web search, content extraction, and library docs for AI agents -- 5-strategy scraping, runs without API keys.
Phase | Status | Scope |
Phase 1 | Shipped | web-core ScrapingAgent migration, smart chunks output, search polish, media slim |
Phase 2 | Shipped | Context7-level docs search: library index (Tier 1 + Tier 2), version-aware queries with token cap, project lock (Cabinets) |
Phase 3 | Shipped |
|
Current release: v3.x.
media(action="analyze")was removed in the v2.0.0 BREAKING release. Useimagine-mcp'sunderstandaction for vision/audio/video analysis. Seedocs/migration.mdfor the upgrade recipe.
Project | Tagline | Tag |
Knowledge graph for token-efficient code reviews -- semantic search and call-... | MCP | |
IMAP/SMTP email for AI agents -- read, send, organize folders, and manage att... | MCP | |
Composite MCP server for Godot Engine -- 17 composite tools for AI-assisted g... | MCP | |
Markdown-first Notion for AI agents -- pages, databases, blocks, and comments... | MCP | |
Telegram for AI agents -- messages, chats, media, and contacts across both bo... | MCP | |
Claude Code plugin marketplace for the n24q02m MCP servers -- install web sea... | Marketplace | |
Image and video understanding + generation for AI agents -- across Gemini, Op... | MCP | |
Chrome Extension for bulk operations on Jules tasks via batchexecute API -- a... | Tooling | |
Shared foundation for building MCP servers -- Streamable HTTP transport, OAut... | MCP | |
Persistent AI memory with hybrid search and embedded sync. Open, free, unlimi... | MCP | |
Lightweight Qwen3 text embedding and reranking via ONNX Runtime and GGUF | Library | |
Secrets without the server. | CLI | |
TACET: a self-distilling neuro-symbolic cascade that amortises LLM cost in kn... | Tooling | |
Shared web infrastructure package for search, scraping, HTTP security, and st... | Library | |
Open-source MCP server for AI agents: web search, content extraction, and lib... | MCP |
Table of contents
Related MCP server: Scout MCP Server
Features
Web Search -- Embedded SearXNG metasearch (Google, Bing, DuckDuckGo, Brave) with query expansion, TTL cache (1 h general / 5 min time-sensitive), standardized citation format, and 200-token snippet cap. Optional cloud search backends (Tavily, Brave, Exa) as a fallback chain via
SEARCH_BACKENDSAcademic Research -- Search Google Scholar, Semantic Scholar, arXiv, PubMed, CrossRef, BASE
Library Docs -- Auto-discover and index documentation with FTS5 hybrid search, HyDE-enhanced retrieval, and version-specific docs
Content Extract -- 5-strategy escalation chain via
n24q02m-web-coreScrapingAgent(basic_http->tls_spoof->headlessCrawl4AI), markitdown bridge for low-tier HTML/MD fallback, smart chunks structured output (clean text + markdown + JSON-LD + code blocks + metadata), batch processing (up to 50 URLs), deep crawling, site mappingLocal File Conversion -- Convert PDF, DOCX, XLSX, CSV, HTML, EPUB, PPTX to Markdown
Media -- List + download images / videos / audio files.
analyzewas removed in v2.0.0 -- useimagine-mcp.understandfor vision/audio inferenceAnti-bot -- Stealth strategies bypass Cloudflare, Medium, LinkedIn, Twitter
Zero Config -- Built-in local Qwen3 embedding + reranking, no API keys needed. Optional cloud providers (Jina AI, Gemini, OpenAI, Cohere, xAI, Anthropic) selected per task via the
EMBEDDING_MODELS/RERANK_MODELS/LLM_MODELSmodel chains for higher-quality vectors and LLM featuresSync -- Cross-machine sync of indexed docs via Google Drive (OAuth Device Code, no browser redirect)
Quick install
# Method 1 (default): plugin install via Claude Code
/plugin marketplace add n24q02m/claude-plugins
/plugin install wet-mcp@n24q02m-plugins
# Method 2 (CLI): direct uvx invocation
claude mcp add wet -- uvx wet-mcp
# Method 3 (recommended for HTTP / multi-device / OAuth)
docker run -d --name wet-mcp-http -p 8084:8080 \
-v wet-data:/data -e MCP_TRANSPORT=http \
-e PUBLIC_URL=https://wet.example.com \
n24q02m/wet-mcp:latestFull setup matrices live at the canonical docs site mcp.n24q02m.com/servers/wet-mcp/setup/ and the paste-to-agent snippets at claude-plugins/plugins/wet-mcp/setup-with-agent.md (per Spec F single source of truth).
Configuration
wet runs zero-config out of the box: web search uses an embedded local SearXNG, and embedding/reranking fall back to the bundled local Qwen3 ONNX models when no cloud keys are set. For higher-quality results, point each task at a cloud model chain. All settings are plain environment variables (no app prefix) -- in the HTTP self-host mode they are entered through the browser setup form instead.
Model chains (CSV provider/model,provider/model; order = fallback). Leave a
chain empty to use the local ONNX models (embedding/rerank) or to disable LLM
features (LLM):
Env var | Task | Empty default |
| Embeddings for docs search | Local Qwen3-Embedding ONNX |
| Result reranking | Local Qwen3-Reranker ONNX |
|
| LLM features disabled |
Provider keys -- the provider is inferred from each model's prefix; supply the
matching key (litellm <PROVIDER>_API_KEY convention):
Model prefix | Key env var | Get it at |
|
| jina.ai/api-key |
|
| aistudio.google.com/apikey |
|
| platform.openai.com |
|
| dashboard.cohere.com |
|
| console.x.ai |
|
| console.anthropic.com |
Any other litellm provider works via env passthrough -- see litellm provider docs for its key name.
Search backends -- SEARCH_BACKENDS (CSV, runtime fallback chain) over
searxng (default, local) plus optional cloud providers tavily / brave /
exa. Point at an external SearXNG with SEARXNG_URL. Cloud providers need
TAVILY_API_KEY / BRAVE_API_KEY / EXA_API_KEY.
Docs sync -- SYNC_ENABLED (default true), GOOGLE_DRIVE_CLIENT_ID
(required for sync), SYNC_FOLDER (default wet-mcp), SYNC_INTERVAL (default
300s). Sync uses Google Drive over the OAuth Device Code flow (no browser
redirect).
HTTP self-host -- MCP_TRANSPORT=http, PUBLIC_URL=<your-domain>. The setup
form is gated by MCP_RELAY_PASSWORD; multi-user deployments also require
CREDENTIAL_SECRET (per-user vault key) and MCP_DCR_SERVER_SECRET.
Example stdio config (cloud chains):
{
"mcpServers": {
"wet": {
"command": "uvx",
"args": ["wet-mcp"],
"env": {
"EMBEDDING_MODELS": "jina_ai/jina-embeddings-v5-text-small",
"RERANK_MODELS": "jina_ai/jina-reranker-v3",
"LLM_MODELS": "gemini/gemini-3-flash-preview",
"JINA_AI_API_KEY": "jina_xxx",
"GEMINI_API_KEY": "AIza_xxx"
}
}
}
}Status
Stable architecture with two transports: stdio (default, local) and
HTTP (self-host, OAuth-gated). No daemon-bridge layer and no auto-spawn
from stdio. The media.analyze action was removed in the v2.0.0 BREAKING
release -- see docs/migration.md for the upgrade
recipe. Current release line: v3.x.
Documentation
Full docs at mcp.n24q02m.com/servers/wet-mcp/setup/:
Setup -- install methods for Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
Modes overview -- stdio / local-relay / remote-relay / remote-oauth
Multi-user setup -- per-JWT-sub credential model
In-repo references (Spec F single source of truth: setup docs live in claude-plugins/plugins/wet-mcp/):
docs/ARCHITECTURE.md-- web-core ScrapingAgent integration, strategy chain, storage layout, LLM provider dispatchdocs/BENCHMARKS.md-- v1.x baseline coverage / latency placeholders + tier-1 fixture metrics
Install with AI agent -- paste this to your AI coding agent:
Install MCP server
wet-mcpfollowing the steps at https://raw.githubusercontent.com/n24q02m/claude-plugins/main/plugins/wet-mcp/setup-with-agent.md
Tools
6 MCP tools (3 domain + config + help + config__open_relay). The legacy
setup tool merged into config action dispatch.
Tool | Description |
| Web (SearXNG metasearch), news, images, academic research (Scholar / arXiv / PubMed / CrossRef / Semantic Scholar / BASE), library docs (HyDE + FTS5), find similar pages. Includes |
| URL -> smart chunks dict ( |
|
|
|
|
| Per-tool documentation: |
| Re-trigger the zero-config relay setup flow (prints a fresh relay URL for the browser form). Registered via |
Media boundary: For vision / audio understanding (image captioning, OCR, audio transcription, video summarization), use imagine-mcp.
media.analyzewas removed in wet v2.0.0 -- useimagine-mcp.understandinstead.
Comparison
How wet-mcp stacks up against direct competitors in each pillar:
Capability | wet-mcp | Brave Search | Tavily | Firecrawl | Context7 |
Web search | Yes (SearXNG aggregation) | Yes | Yes | No | No |
Extract URL | Yes (5-strategy chain) | No | Yes (basic) | Yes | No |
Media list / download | Yes | No | No | No | No |
Library docs search | Yes (Tier 1 curated + Tier 2 on-demand, version-aware, Cabinets) | No | No | No | Yes |
Academic research | Yes (6 providers) | No | No | No | No |
Self-hostable | Yes | No | No | No | Yes |
Free tier | Yes (open source) | Limited | Limited | Limited | Yes |
Security
SSRF prevention -- URL validation on crawl targets
Graceful fallbacks -- Cloud → Local embedding, multi-tier crawling
Error sanitization -- No credentials in error messages
File conversion sandboxing -- Optional
CONVERT_ALLOWED_DIRSrestriction
Build from Source
git clone https://github.com/n24q02m/wet-mcp.git
cd wet-mcp
uv sync
uv run wet-mcpDeploy to Cloudflare
Run your own single-user wet instance serverless on Cloudflare (Containers + D1 + Vectorize + KV).
Prerequisites: a Cloudflare account on the Workers Paid plan and the wrangler CLI.
git clone https://github.com/n24q02m/wet-mcp && cd wet-mcpwrangler loginProvision resources and apply the D1 schema:
wrangler d1 create wet-docs wrangler d1 execute wet-docs --file migrations/0001_init_wet.sql --remote wrangler vectorize create wet-docs-vectors --dimensions 768 --metric cosine wrangler kv namespace create wet-kvPaste the returned IDs into
wrangler.jsonc.Push the container image to your Cloudflare managed registry (CF Containers cannot pull from external registries directly), then set
<YOUR_ACCOUNT_ID>inwrangler.jsonc:docker pull ghcr.io/n24q02m/wet-mcp:beta docker tag ghcr.io/n24q02m/wet-mcp:beta wet-mcp:beta wrangler containers push wet-mcp:beta # prints registry.cloudflare.com/<ACCOUNT_ID>/wet-mcp:betaSet secrets (use
SEARXNG_URLwith basic-auth userinfo, e.g.https://user:pass@searxng.example.com, orTAVILY_API_KEYif you setSEARCH_BACKEND=tavily):wrangler secret put CREDENTIAL_SECRET wrangler secret put JINA_AI_API_KEY wrangler secret put GOOGLE_VERTEX_EXPRESS_API_KEY wrangler secret put XAI_API_KEY wrangler secret put MCP_RELAY_PASSWORD wrangler secret put MCP_DCR_SERVER_SECRET wrangler secret put SEARXNG_URLwrangler deployand complete setup in the browser relay form at your Worker domain.
Storage maps to Cloudflare via MCP_STORAGE_BACKEND=cf-kv (credentials/tokens, encrypted),
DOCS_DB_BACKEND=cf-d1 (docs + BM25 full-text), and Vectorize (embeddings). Web search uses
a SearXNG instance (SEARCH_BACKEND=searxng, SEARXNG_URL) or Tavily (SEARCH_BACKEND=tavily);
embed/rerank are forced cloud via EMBEDDING_MODELS/RERANK_MODELS.
Trust Model
This plugin implements TC-Local (machine-bound, single trust principal). See mcp-core trust model for full classification.
Mode | Storage | Encryption | Who can read your data? |
stdio (default) |
| AES-GCM, machine-bound key | Only your OS user (file perm 0600) |
HTTP self-host | Same as stdio | Same | Only you (admin = user) |
License
MIT -- See LICENSE.
Available Tools
6 toolsconfigCIdempotent
Server config and management. Actions: status|set|cache_clear|docs_reindex|warmup|setup_sync|setup_status|setup_skip|setup_reset|setup_complete. Use help tool with tool_name='config' for full docs.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| key | No | ||
| value | No | ||
| remote_type | No | ||
| force | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide idempotentHint but the description lists actions that may not all be idempotent (e.g., setup_reset). No additional behavioral context such as side effects, authorization needs, or rate limits is provided. The description does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise (two sentences), but it externalizes necessary information to another tool ('Use help tool for full docs'), which degrades structure. It is not verbose, but it is incomplete.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, 9 actions, output schema exists), the description is severely lacking. It provides no detail about action semantics, parameter usage, or when to set vs. status. The referral to help tool indicates incompleteness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate but fails to explain any of the four optional parameters (key, value, remote_type, force). The action list gives context but no parameter details. This is insufficient for an agent to correctly invoke the tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Server config and management' and lists distinct actions, making the purpose evident. It differentiates from sibling 'config__open_relay' as a general config tool versus a specific relay config.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It only suggests using the help tool for full docs, shifting the burden away from the description. Siblings like 'search' or 'extract' are not compared, leaving the agent without decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
config__open_relayA
Open the relay configuration form for wet-mcp in the user's browser. Returns the relay URL, whether the browser launched, and the current status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that a browser is launched and what is returned, but does not mention potential side effects (e.g., user interaction required) or whether the action is reversible. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that front-load the purpose and efficiently convey the action and return values with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with no parameters and an output schema, the description covers the action and return values adequately. However, it could briefly explain what the 'relay configuration form' is or why one would use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema coverage is trivially 100%. The description adds value by explaining the tool's action and outputs, justifying the baseline of 4 for parameterless tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verbs ('Open'), identifies the resource ('relay configuration form for wet-mcp'), and explicitly states the return values (relay URL, browser launch status, current status). It is clearly distinguishable from sibling tools like 'config' or 'search'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus its siblings. The description only states what it does, without indicating prerequisites, alternatives, or conditions for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
extractARead-only
Read and return full page content from URLs or local files. Use this when you have a specific URL and need its content. For finding URLs first, use the search tool instead.
Actions:
extract: Get clean content from URLs. Example: extract(action="extract", urls=["https://example.com/article"])
batch: Batch extract with per-domain rate limiting (max 50 URLs). Example: extract(action="batch", urls=["https://a.com/1", "https://b.com/2"])
crawl: Deep crawl following links from root URLs. Example: extract(action="crawl", urls=["https://docs.example.com"], depth=2)
map: Discover site URL structure without extracting content. Example: extract(action="map", urls=["https://example.com"])
convert: Convert local files (PDF, DOCX, PPTX, XLSX) to Markdown. Example: extract(action="convert", paths=["/home/user/report.pdf"])
extract_structured: Extract structured data using JSON Schema + LLM. Example: extract(action="extract_structured", urls=["https://example.com/pricing"], schema={"type": "object", "properties": {"price": {"type": "string"}}})
agent: Multi-step research orchestration -- search the web, extract top results, synthesize a cited Markdown answer. Example: extract(action="agent", query="latest pydantic 2 changes", max_urls=5)
interact: Drive a page with click/fill/submit via patchright. Example: extract(action="interact", url="https://example.com/login", actions=[{"type": "fill", "selector": "#email", "value": "x@y.com"}, {"type": "submit", "selector": "form"}])
Key parameters:
urls (required for extract/batch/crawl/map/extract_structured): List of URLs
paths (required for convert): List of local file paths
query (required for agent): Research question to answer
url (required for interact): Page URL to drive
actions (required for interact): List of {type, selector?, description?, value?} ops
max_urls (agent): Default 5, hard cap 20
synthesis_model (agent): Override LLM model for the synthesis step
token_budget (agent): Max prompt tokens (default 10000)
session (interact): Persistent session id; reuses browser across calls
screenshot (interact): Capture post-interaction screenshot
format: Output format -- "markdown" (default), "text", "html"
depth: Crawl depth (default: 2, max: 5)
max_pages: Max pages for crawl/map (default: 20, max: 100)
stealth: Enable anti-bot bypass for protected sites (default: false)
schema: JSON Schema dict for extract_structured
Use help tool with tool_name="extract" for full parameter documentation.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| urls | No | ||
| paths | No | ||
| depth | No | ||
| max_pages | No | ||
| format | No | markdown | |
| stealth | No | ||
| schema | No | ||
| prompt | No | ||
| query | No | ||
| max_urls | No | ||
| synthesis_model | No | ||
| token_budget | No | ||
| actions | No | ||
| session | No | ||
| screenshot | No | ||
| url | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and openWorldHint. The description adds extensive behavioral context: it explains rate limiting for batch, stealth mode for bot bypass, default and max values for depth and max_pages, conversion of local files, structured extraction with LLM, multi-step research (agent), and page interaction (interact). No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but well-structured with sections: overall purpose, list of actions with examples, key parameters, and a note to use help. It is front-loaded with the core purpose. Every sentence is informative, though some details could be condensed. Given the tool's complexity, the length is justified.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (17 parameters, 8 actions), the description is fairly complete. It covers all actions, key parameters, defaults, and constraints. Since there is an output schema, it does not need to describe return values in detail. It also addresses the openWorldHint by explaining that responses can vary (e.g., depending on URL content).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description carries full burden. It lists 'Key parameters' and explains which parameters are required for each action (e.g., urls for extract, paths for convert). It also describes the format for interact actions and defaults for many parameters. However, a few parameters like 'prompt' are not detailed, and not every parameter is explicitly mentioned.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Read and return full page content from URLs or local files', specifying the verb and resource. It also distinguishes from the sibling 'search' tool by saying 'For finding URLs first, use the `search` tool instead.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Use this when you have a specific URL and need its content.' It also contrasts with the `search` tool for finding URLs. Additionally, it breaks down multiple actions (extract, batch, crawl, etc.) with examples, helping the agent choose the right action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
helpARead-onlyIdempotent
Get detailed documentation for any tool. Call this when you need full parameter reference or usage examples.
Valid tool_name values: search, extract, media, config.
Quick guide -- which tool to use:
Need to FIND information? Use
search(returns result listings with URLs)Need to READ a page? Use
extract(returns full page content from a URL)Need media files? Use
media(discover, download images/videos/audio)Need server settings? Use
config(status, cache, settings, warmup, sync setup)
| Name | Required | Description | Default |
|---|---|---|---|
| tool_name | No | search |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint and idempotentHint true. The description adds that it returns documentation and examples, but no contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Concise yet comprehensive; includes a well-structured quick guide. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers all necessary context: what the tool does, valid inputs, and differentiation from siblings. Output schema exists, so return values are covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema coverage, the description lists valid tool_name values and explains their purpose, adding significant meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it provides documentation for any tool, listing valid tool_name values and differentiating sibling tools in a quick guide.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly specifies when to call this tool (when needing full parameter reference or usage examples) and provides a quick guide for using sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
mediaA
Discover and download media files (images, videos, audio) from web pages.
Actions:
list: Scan a page and return media URLs with metadata. Example: media(action="list", url="https://example.com/gallery", media_type="images")
download: Download media files to local storage. Example: media(action="download", media_urls=["https://example.com/photo.jpg"])
Key parameters:
url (required for list): Page URL to scan
media_urls (required for download): List of media URLs to download
media_type: Filter for list -- "images", "videos", "audio", "files", "all" (default: "all")
output_dir: Download directory (default: ~/.wet-mcp/downloads)
prompt: Reserved -- accepted for backward compatibility, ignored
Typical workflow: list (discover) -> download (save locally). For LLM analysis (vision/audio/video), hand the downloaded path to imagine-mcp's understand action. The legacy media(action="analyze") was REMOVED in wet v2.0.0 (deprecated since v1.x.y); calling it now returns the standard unknown-action error.
Use help tool with tool_name="media" for full documentation.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| url | No | ||
| media_type | No | all | |
| media_urls | No | ||
| output_dir | No | ||
| max_items | No | ||
| prompt | No | Describe this image in detail. |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the side effects of downloading files to local storage and notes that the 'prompt' parameter is ignored for backward compatibility. It also mentions that the 'analyze' action has been removed and returns an error. However, it does not cover rate limits, authentication, or potential overwriting behavior. Annotations (readOnlyHint=false, openWorldHint=true) are consistent with the description, and no contradiction is present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with bullet points for actions and parameters, and includes a typical workflow section. It is somewhat verbose due to the deprecation notice, but every sentence adds value. The purpose is front-loaded, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, output schema exists but not described), the description covers the main workflow, actions, parameters, and deprecation. It lacks details on the output schema (e.g., metadata structure) and does not address the 'max_items' parameter, but is otherwise complete for typical use cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description adds significant meaning by explaining each parameter's role (url for list, media_urls for download, media_type filter, output_dir default) and providing examples. However, the 'max_items' parameter from the schema is not mentioned, leaving a gap in documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: discover and download media files from web pages. It specifies two distinct actions (list and download) with examples, and explicitly notes the removal of the 'analyze' action, which helps avoid confusion. The tool's scope is well-defined and distinct from sibling tools like extract or search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a typical workflow (list then download) and mentions using imagine-mcp for analysis, but does not explicitly compare to sibling tools or state when not to use this tool. It offers some context for usage but lacks explicit exclusions or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchARead-onlyIdempotent
Find information across web, academic sources, or library docs. Returns search result listings (titles, URLs, snippets) -- NOT full page content. To read full content from a URL, use the extract tool instead.
Actions:
search: Web search via SearXNG. Example: search(action="search", query="python async patterns")
research: Academic/scientific search (Google Scholar, arXiv, PubMed). Example: search(action="research", query="transformer attention mechanism")
docs: Search library documentation with auto-indexing. Example: search(action="docs", query="how to create routes", library="fastapi")
docs_resolve: Free-form library name to ranked library_id list. Example: search(action="docs_resolve", query="react")
docs_query: Version-aware library docs query honoring project lock + token cap. Example: search(action="docs_query", library="react", version="latest", topic="useState", query="how to set initial state")
docs_lock_project: Detect project manifests (pyproject/package.json/go.mod/Cargo.toml) and lock the library set for Cabinets isolation. Example: search(action="docs_lock_project", project_path="/repo/my-app")
similar: Find pages similar to a URL (pass URL as query). Example: search(action="similar", query="https://example.com/article")
Key parameters:
query (required for all actions): Search terms or URL (for similar)
library (required for docs): Library name, e.g. "react", "fastapi"
language: Programming language for disambiguation in docs, e.g. "python", "java"
expand: Enable LLM query expansion for broader coverage (default: false)
enrich: Fetch actual page content for richer snippets (default: false, adds latency)
max_results: Number of results (default: 10)
time_range: Recency filter -- day, week, month, year
include_domains / exclude_domains: Domain filters
Use help tool with tool_name="search" for full parameter documentation.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| query | No | ||
| library | No | ||
| version | No | ||
| topic | No | ||
| project_path | No | ||
| language | No | ||
| categories | No | general | |
| max_results | No | ||
| limit | No | ||
| time_range | No | ||
| include_domains | No | ||
| exclude_domains | No | ||
| expand | No | ||
| enrich | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that search returns listings not full content, mentions latency for `enrich` parameter, and aligns with annotations (read-only, idempotent, open-world). Adds context beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with action sections and parameter descriptions, but lengthy. Every sentence adds value, though slightly verbose. Front-loaded with main purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with 15 parameters and multiple actions, the description thoroughly covers all modes, parameters, and examples. Output schema exists, but description already explains return format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description fully explains each key parameter (query, library, language, expand, enrich, max_results, etc.) with examples, providing essential meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool finds information across web, academic, or library docs, and lists specific actions with examples. It distinguishes from sibling tool `extract` by noting that search returns listings not full content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly explains when to use each action (e.g., research for academic, docs for library) and directs users to `extract` for full page content, providing clear alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v3.3.0-beta.19- First observed
config - First observed
config__open_relay - First observed
extract - First observed
help - First observed
media - First observed
search
TDQS
Most tools have distinct purposes (config, extract, search, media, help). However, config__open_relay is a specific action closely related to config, which could cause some ambiguity. Overall, descriptions help differentiate them.
Tool names use lowercase with underscores, but patterns vary: single words (config, extract, help, media, search) vs. double underscore (config__open_relay). No consistent verb_noun pattern.
6 tools is well-scoped for a web extended toolkit. Each tool covers a core area (config, extraction, search, media, help), no redundancy or obvious missing essentials.
Covers key web tasks: search, content extraction (including crawl, interact, convert), media handling, and server config. Minor gaps like more advanced web automation or URL management, but sufficient for typical use cases.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
LLM-ready web search + instant answers + URL-to-clean-text fetch for agents and RAG.
Web search for AI agents — one tool across 6 engines, routed to the cheapest + cached.
Web scraping for AI agents. Extract text and metadata from any URL worldwide. $0.005/page.
The best web search for your AI Agent
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceWeb search, clean page reading & one-call research dossiers for AI agents. No API key — your agent does the synthesis.124MIT

Scout MCP Serverofficial
AlicenseAqualityBmaintenanceProvides coding agents with live web capabilities including web search, scraping to Markdown, structured extraction, crawling, screenshots, and company lookup, all with zero dependencies.81MIT- AlicenseNot gradedqualityBmaintenanceProvides web search and content extraction for AI agents.MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to perform web searches, extract webpage content, and conduct end-to-end search-and-extract operations using multiple search providers and content extraction methods.-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/expandingideas-ai/mcp-wet'
If you have feedback or need assistance with the MCP directory API, please join our Discord server