Server data from the Official MCP Registry
Open-source MCP server for AI agents: web search, content extraction, and library docs.
About
Open-source MCP server for AI agents: web search, content extraction, and library docs.
Security Report
Valid MCP server (1 strong, 1 medium validity signals). No known CVEs in dependencies. Package registry verified. Imported from the Official MCP Registry.
4 files analyzed · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Required
This plugin requests these system permissions. Most are normal for its category.
What You'll Need
Set these up before or after installing:
Environment variable: OPENROUTER_API_KEY
Environment variable: GITHUB_TOKEN
How to Install
Add this to your MCP configuration file:
{
"mcpServers": {
"n24q02m-wet": {
"command": "uvx",
"args": [
"n24q02m-wet==3.23.0"
],
"env": {
"GITHUB_TOKEN": "your-github-token-here",
"OPENROUTER_API_KEY": "your-openrouter-api-key-here"
}
}
}
}Some servers take additional arguments. See the repository for details.
Documentation
View on GitHubFrom the project's GitHub README.
WET - Web Extended Toolkit MCP Server
Open-source MCP server for AI agents: web search, content extraction, and library docs.
Distribution & CLI: the repo, CLI and Python module are
wet. The PyPI distribution isn24q02m-wet(installpip install n24q02m-wet/uvx --python 3.13 n24q02m-wet). wet is an HTTP-only MCP server: start it withwet server startand point clients athttp://127.0.0.1:8000/mcp. There is no stdio mode; a barewetprints the control-plane usage. Thewetandwet-mcpaliases remain available.
mcp-name: io.github.n24q02m/wet
| 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 | extract.agent multi-step research with cited synthesis, extract.interact click/fill/submit via patchright (optional session persistence), docs_004_chunk_summaries migration, media.analyze removed (v2.0.0) |
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 |
|---|---|---|
| better-semantic-release | Drop-in python-semantic-release fork with built-in release-safety guards (orp... | Tooling |
| claude-plugins | Claude Code plugin marketplace for the n24q02m MCP servers -- install web sea... | Marketplace |
| crg | 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 | |
| fastretrieval | Fast multi-model retrieval runtime: ONNX and GGUF embeddings, reranking, and ... | Tooling |
| hull | hull is the shared monorepo core for the wet, crg and mnemo self-hosted stack | MCP |
| jules-task-archiver | Chrome Extension for bulk operations on Jules tasks via batchexecute API -- a... | Tooling |
| mnemo | Persistent AI memory with hybrid search. Open, free, unlimited. | MCP |
| notion | Markdown-first Notion for AI agents -- pages, databases, blocks, and comments... | MCP |
| skret | Secrets without the server. | CLI |
| tacet | A self-distilling neuro-symbolic cascade that amortises LLM cost across knowl... | Tooling |
| telegram | Telegram for AI agents -- messages, chats, media, and contacts across both bo... | MCP |
| tools-docs | Docs portal for the n24q02m open-source tool stack (skret, MCP plugins, hull,... | Tooling |
| wet | Open-source MCP server for AI agents: web search, content extraction, and lib... | MCP |
| workspace | Google Workspace MCP server (Docs/Drive/Calendar/Gmail/Sheets/Slides/Tasks/Ch... | MCP |
Table of contents
- Features
- Status
- Quick install
- Self-host usage
- Configuration
- Documentation
- Tools
- CLI
- Comparison
- Security
- Build from Source
- Trust Model
- License
Features
- Web Search -- Multi-backend metasearch with query expansion, TTL cache (1 h general / 5 min time-sensitive), standardized citation format, and 200-token snippet cap. Backends run as a fallback chain via
SEARCH_BACKENDS; the zero-config default istavily,duckduckgo(Tavily when keyed, DuckDuckGo always) and the rest are Tavily, Brave, Exa, Kagi, OpenRouter, Firecrawl, Startpage - Academic Research --
search(action="research")runs theSEARCH_BACKENDSchain with thesciencecategory (only asearxngbackend applies it), reranks the hits, and tags each result by source domain (arXiv, Google Scholar, Semantic Scholar, PubMed, DOI) - 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 the
hull_webScrapingAgentfromn24q02m-hull(basic_http->tls_spoof-> render backends fromBROWSER_BACKENDS(native/browserless/invisible) -> optional key-gatedcaptcha), 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 mapping - Local 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 inference - Anti-bot -- Stealth strategies bypass Cloudflare, Medium, LinkedIn, Twitter
- Zero Config -- Built-in local reference embedding + reranking through fastretrieval, no API keys needed. Optional cloud models configured per task via the
[models.embed|rerank|chat|jev_score]cells in~/.wet/config.toml(OpenRouter default; oneOPENROUTER_API_KEYserves every cell)
Quick install
# Method 1 (default): plugin install via Claude Code
/plugin marketplace add n24q02m/claude-plugins
/plugin install wet@n24q02m-plugins
# Method 2 (CLI): start a local instance, then register its HTTP endpoint
uvx --python 3.13 --from n24q02m-wet wet server start
claude mcp add --transport http wet http://127.0.0.1:8000/mcp
# Method 3 (always-on): compose stack from a clone of this repo (token auth)
docker compose up --build -d
# Method 4 (remote): point a client at an HTTP deployment
claude mcp add --transport http wet https://<your-host>/mcp
Every method needs a running instance: wet never runs as a client-spawned subprocess. Install matrix (all Streamable HTTP; see the Setup page for full steps):
| Client | Install |
|---|---|
| Claude Code (plugin) | /plugin marketplace add n24q02m/claude-plugins then /plugin install wet@n24q02m-plugins (set WET_URL, default http://127.0.0.1:8000/mcp; optional WET_TOKEN); start the instance first |
| Claude Code (CLI) | claude mcp add --transport http wet http://127.0.0.1:8000/mcp |
| Codex | register the HTTP URL under mcp_servers in ~/.codex/config.toml |
| Gemini CLI | add the mcpServers JSON below to ~/.gemini/settings.json |
| Cursor / Windsurf | add the mcpServers JSON below via the client's MCP settings (mcp.json) |
| Any client (HTTP self-host) | point the client at https://<your-host>/mcp (Streamable HTTP, Bearer token when auth = "token" / "multi") |
Public OCI image publication is discontinued. Existing historical registry tags remain untouched; new container deployments build from source or use the Cloudflare-managed registry.
The HTTP endpoint speaks Streamable HTTP. With auth = "token" or "multi"
the client sends Authorization: Bearer <token>; no-auth is loopback-only.
Stand one up via Method 2 or 3.
Full setup matrices live at the canonical docs site mcp.n24q02m.com/servers/wet/setup/ and the paste-to-agent snippets at claude-plugins/plugins/wet/setup-with-agent.md (per Spec F single source of truth).
Self-host usage
Two supported ways to run the always-listening HTTP server. In both, the MCP
endpoint is http://127.0.0.1:8000/mcp (Streamable HTTP) and the config root
is ~/.wet/ (config.toml, docs.db, subs/). Never run the server as a
spawned subprocess of a client — register the endpoint in your client instead.
Dev (uv, no-auth loopback)
git clone https://github.com/n24q02m/wet && cd wet
uv run wet config init # writes ~/.wet/config.toml (default: auth = "no-auth")
uv run wet server start # serves http://127.0.0.1:8000/mcp (--foreground to stay attached)
no-auth refuses non-loopback binds — the server is localhost-only until you
switch to token auth.
Always-on (docker)
# 1. Mint a token and its scrypt hash (hull-core canonical; the hash command
# never echoes the token itself)
TOKEN=$(openssl rand -hex 32) # the token — give it to clients, keep it secret
printf '%s' "$TOKEN" | uv run wet token hash # paste the output as token_hash
# 2. Instance config from the example
cp docker-config/config.example.toml docker-config/config.toml
# edit [server] token_hash and the [models.*] cells (see below)
# 3. Data continuity (optional): carry an existing instance over by copying
# docs.db and subs/ into the wet-home named volume BEFORE first start:
docker volume create wet-wet-home && \
docker cp ~/.wet/docs.db wet-wet-home:/docs.db && \
docker cp ~/.wet/subs wet-wet-home:/subs # adjust: files land as root, chown 999:999
docker compose up -d --build
Compose publishes 127.0.0.1:${WET_PORT:-8000} → container 8000 (loopback
only) and mounts docker-config/config.toml read-only at
/home/appuser/.wet/config.toml. Persistent data (docs.db, subs/) lives in
the wet-home named volume; the download/cache dir in wet-data. Editing the
config takes effect on docker compose restart.
Consumers
# CLI (talks to the running server over HTTP; exits 2 with a hint when none runs):
uvx --python 3.13 --from n24q02m-wet wet search "<query>"
# MCP client (Claude Code):
claude mcp add --transport http wet http://127.0.0.1:8000/mcp \
--header "Authorization: Bearer <token>"
# Raw probe:
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8000/mcp \
-X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' # 401
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8000/mcp \
-X POST -H 'Authorization: Bearer <token>' -H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"curl","version":"0"}}}' # 200
Config: local vs cloud models
The [models.embed|rerank|chat|jev_score] cells in ~/.wet/config.toml are
per-task (each its own base_url + api_key + model, OpenAI-spec). The
example ships OpenRouter examples; any OpenAI-compatible endpoint works —
cloud, or a local server such as Ollama (base_url = "http://host.docker.internal:11434/v1" from the container). Keys in the file
are host-only material; alternatively leave api_key = "" and inject at start
via HULL_EMBED_API_KEY / HULL_RERANK_API_KEY / HULL_CHAT_API_KEY /
HULL_JEV_SCORE_API_KEY.
Configuration
wet runs zero-config out of the box: web search falls back to credential-free
DuckDuckGo (Tavily when a key is present), and embedding/reranking fall back to the bundled local ONNX models through
fastretrieval when no cloud keys are set. For higher-quality results, configure
the per-task provider cells in ~/.wet/config.toml. Operational settings are
plain environment variables (no app prefix) -- in HTTP self-host mode configure them via environment variables or ~/.wet/config.toml.
Provider cells -- [models.embed|rerank|chat|jev_score] each take their own
base_url + api_key + model (OpenAI-spec). OpenRouter is the pre-wired
default for every cell; any OpenAI-compatible endpoint works. Cell keys may be
left empty in the file and injected at start via HULL_EMBED_API_KEY /
HULL_RERANK_API_KEY / HULL_CHAT_API_KEY / HULL_JEV_SCORE_API_KEY. When a
cell keeps the OpenRouter default base_url, OPENROUTER_API_KEY in the
environment serves it as a last-resort credential — one OpenRouter key can
power every task. Empty embed/rerank cells fall back to the local ONNX models;
an unkeyed chat cell disables LLM features (e.g. extract(action="agent")).
FASTRETRIEVAL_CACHE_PATH controls the local model cache.
Search backends -- SEARCH_BACKENDS is an ordered runtime fallback chain:
tavily / brave / exa / kagi / openrouter (keyed), firecrawl / keenable (optional key),
and credential-free duckduckgo / startpage. The default chain is
tavily,duckduckgo. searxng runs only when it is named in SEARCH_BACKENDS:
against a third-party instance at SEARXNG_URL, or, with the opt-in
WET_AUTO_SEARXNG=true, a local SearXNG that wet installs (server startup or
wet warmup) and starts when a search needs it
(DISABLE_LOCAL_SEARCH blocks the local one). Keyed providers use TAVILY_API_KEY, BRAVE_API_KEY, EXA_API_KEY,
KAGI_API_KEY, or OPENROUTER_API_KEY (comma-separate for rotation). The
openrouter backend runs the query through a chat completion with the
openrouter:web_search server tool and maps the returned url_citation
annotations onto the shared result shape. OPENROUTER_MODEL has no default and
is required: the backend refuses to run until it is set. OPENROUTER_BASE_URL
and OPENROUTER_SEARCH_ENGINE override the endpoint and search engine. Firecrawl attempts a keyless request when FIRECRAWL_API_KEY
is absent, and Keenable uses its keyless public endpoint when KEENABLE_API_KEY is absent; rejection or a DuckDuckGo/Startpage bot challenge advances the chain.
Result reranking uses the configured rerank cell ([models.rerank] — cloud via OpenRouter by default, or local ONNX when unkeyed); the same chain serves web search, research, similar-page search, agent search, and docs discovery/indexing fallbacks. Providers use their own search capabilities; category filters that only SearXNG exposed are no longer applied by default.
Browser render backends -- BROWSER_BACKENDS (CSV, escalation chain) picks
the headless render leg of extract: native (in-process chromium, the
zero-config default), browserless (only against a third-party managed
instance -- set BROWSERLESS_URL + BROWSERLESS_TOKEN; the project's own
self-hosted render service was retired), and invisible (see below). Empty
chain falls back to native. Set CAPSOLVER_API_KEY to append an optional,
key-gated CAPTCHA tier as the last escalation step.
Robots policy -- set RESPECT_ROBOTS_TXT=true to enforce robots.txt
across both the extract strategy chain and the Crawl4AI-backed crawl,
sitemap, and list_media actions. The default is false to preserve existing
deployment behaviour; configure this process-level policy explicitly when the
operator requires robots enforcement.
Invisible tier + seeded identity (opt-in) -- append invisible to
BROWSER_BACKENDS to add a stealth-Firefox engine tier as the last escalation
step (n24q02m-hull[invisible] extra: pip install "n24q02m-wet[invisible]"). One
coherent browser identity spans the whole chain: seed it with WET_IDENTITY_SEED
(or let wet derive once and persist it under ~/.wet/subs/<sub>/identity.json)
and install the wet[identity] extra. Without the extras the chain keeps
legacy behaviour (warn-once). STEALTHFOX_BINARY points at a patched Firefox
build to skip the engine download; IDENTITY_PROFILE_DIR (default
~/.wet/subs/<sub>/profiles) keeps persistent browser profiles per namespace.
Disable local fallbacks -- opt out of the heavy in-process local fallbacks
per capability (e.g. on a slim container that renders/searches/embeds via cloud
backends only): DISABLE_LOCAL_BROWSER, DISABLE_LOCAL_SEARCH,
DISABLE_LOCAL_EMBED, DISABLE_LOCAL_RERANK.
Auth -- [server] auth in ~/.wet/config.toml is no-auth (loopback only), token (store only token_hash, see wet token hash) or multi (per-user tokens). Server-host settings such as OPENROUTER_API_KEY belong to the process that runs wet server start (or the compose environment), not to the MCP client config.
Example client config (add headers with the Bearer token for token / multi):
{
"mcpServers": {
"wet": {
"type": "http",
"url": "http://127.0.0.1:8000/mcp"
}
}
}
To use a different endpoint or model per task, edit the [models.*] cells in
~/.wet/config.toml, or inject HULL_EMBED_API_KEY / HULL_RERANK_API_KEY /
HULL_CHAT_API_KEY / HULL_JEV_SCORE_API_KEY at start instead of storing keys
in the file.
Status
Stable architecture with a single transport: Streamable HTTP, always served by
wet server start (self-host). No stdio mode, no daemon-bridge layer and no
auto-spawn by clients. 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/setup/:
- Setup -- install methods for Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
- Modes overview -- transports and HTTP auth modes
- Multi-user setup --
multimode: per-user tokens fromusers.toml, one namespace per user
In-repo references (Spec F single source of truth: setup docs live in claude-plugins/plugins/wet/):
docs/ARCHITECTURE.md--hull_webScrapingAgent 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
wetfollowing the steps at https://raw.githubusercontent.com/n24q02m/claude-plugins/main/plugins/wet/setup-with-agent.md
Tools
5 MCP tools (3 domain + config + help). The legacy
setup tool merged into config action dispatch.
| Tool | Description |
|---|---|
search | Web (multi-backend metasearch), news, images, academic research (search chain with the science category; searxng maps it to Scholar / arXiv / PubMed / CrossRef / Semantic Scholar / BASE), library docs (HyDE + FTS5), find similar pages. Includes docs_resolve (library name -> ranked id), docs_query (version-aware + topic + 5000-token cap), docs_lock_project (Cabinets project pin via pyproject / package.json / go.mod / Cargo.toml manifest detection). |
extract | URL -> smart chunks dict (clean_text + markdown + structured_data + code_blocks + metadata) via the hull_web 5-strategy chain. Batch processing (up to 50 URLs), deep crawling, site mapping, local file conversion (PDF/DOCX/XLSX/PPTX/EPUB), structured extraction (JSON Schema) |
media | list (discover URLs from gallery pages), download (SSRF-safe). analyze was removed in v2.0.0 -- use imagine-mcp.understand instead |
config | status, set, cache_clear, docs_reindex, warmup |
help | Per-tool documentation: search, extract, media, config |
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.
CLI
The package installs three console scripts: n24q02m-wet (primary package command), wet (short alias), and wet-mcp (legacy alias). wet is the control plane for the HTTP server plus one thin client; a bare invocation prints its usage.
uvx --python 3.13 --from n24q02m-wet wet warmup # try a subcommand without a persistent install
wet server start # start the Streamable HTTP server (detached; --foreground to attach)
wet server status # pid, lock and HTTP liveness
wet server stop
wet config init # write ~/.wet/config.toml; `config get|set` reads/edits one key
printf '%s' "$TOKEN" | wet token hash # print the storable scrypt hash (token from stdin, or a hidden prompt; argv is refused)
wet users path # print the users.toml path
wet docs list # indexed library names (the input for `docs reindex`)
wet docs reindex <library> # drop the cached docs index for <library>; the next docs search re-indexes it
wet search "<query>" # call the running server; exits 2 when it is down
wet warmup # first-run setup (browser deps; SearXNG with WET_AUTO_SEARXNG), then check cloud model cells or pre-download local models
Every subcommand prints its result and exits; there is no interactive auth or credential flow in the CLI. Google Drive sync lives in better-drive, not in wet.
| Capability | wet | Brave Search | Tavily | Firecrawl | Context7 |
|---|---|---|---|---|---|
| Web search | Yes (multi-backend chain) | 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 (search chain, science category) | 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 -- Defaults to the working directory and temp dir; override with
CONVERT_ALLOWED_DIRS
Build from Source
git clone https://github.com/n24q02m/wet.git
cd wet
uv sync
uv run wet
Trust Model
wet keeps its state on the host that runs wet server start. config.toml
and docs.db are plain files under ~/.wet/; protect them with file
permissions. Provider keys seeded into hull's credential pool are sealed with
AES-256-GCM under a host key file; see hull's
provider key pools
for the store.
| Mode | Storage | Encryption | Who can read your data? |
|---|---|---|---|
HTTP, no-auth (loopback) | ~/.wet/ | None for config.toml / docs.db; pooled keys AES-256-GCM in ~/.hull/hull.db | Your OS user and anything that reaches the loopback port |
HTTP, token / multi | ~/.wet/ (cache, identity and profiles under subs/<sub>/) | Same | Holders of a token; multi gives each user its own subs/<sub>/, while docs.db stays shared |
License
Apache-2.0 -- See LICENSE.
Reviews
No reviews yet
Be the first to review this server!
More Search & Web MCP Servers
Browser Use
Freeby Browser Use · Search & Web
Browser agents and stealth cloud browsers for AI: run web tasks, fill forms, extract data.
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
mcp-creator-python
Freeby mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.
by Lharries · Communication
Read, search, and send WhatsApp messages through your AI assistant
FinAgent
Freeby mcp-marketplace · Finance
Free stock data and market news for any MCP-compatible AI assistant.
