🐕 Hound
Give your AI agent the web. $0. Two commands. No keys.
Fetch · crawl · bypass bot walls · read PDFs (even scanned) · search the web One MCP server · one warm browser · zero accounts · runs on your machine
Power your agent
पब्लिशर का इंस्टॉल। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
रजिस्ट्री में अभी कोई पैकेज्ड रिलीज़ नहीं है। रिपॉज़िटरी का README देखें.
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
Give your AI agent the web. $0. Two commands. No keys.
Fetch · crawl · bypass bot walls · read PDFs (even scanned) · search the web One MCP server · one warm browser · zero accounts · runs on your machine
MCP server for web fetching with Cloudflare bypass, Trafilatura extraction, and smart routing. Free, self-hosted, no API keys.
pip install hound-mcp[all] && playwright install chromium
Install · The 6 tools · Search · Comparison · Gotchas · Honest limits
Same prompt, three tools. Hound does the whole thing on its own, search + fetch + crawl, locally. The others get stuck on the parts they don't do.
BYOK search · intent-aware multi-query fan-out · six-signal ranking · next-gen stealth engine.
hound keys add. Keys become the primary search source with key stacking (multiple keys per provider, auto-rotation on rate limit), automatic fallback to Hound's keyless local engines when all keys are exhausted. CLI key management: hound keys add/list/test/remove/clear.navigator.webdriver=undefined, canvas noise, permissions API), human behavior simulation (Bezier mouse curves, natural scroll), CF Turnstile solver with human-like mouse movement. Passes bot.sannysoft.com, bypasses Cloudflare Turnstile on CanadianInsider (hardest in a 31-site benchmark), Medium, StackOverflow, NowSecure, Glassdoor (DataDome). See the stealth benchmark below.fetcher.py (primp-based HTTP), browser.py (patchright-based browser), extractor.py (trafilatura + markdownify). Smaller install, fewer transitive deps, faster cold start.pip install hound-mcp pulls no browser deps. On platforms without playwright (Termux, aarch64), hound runs in HTTP-only mode with graceful degradation.[], browser startup failure cleans partial sessions, hound --rollback works for pinned older versions, focus and actions now forwarded from MCP dispatcher to smart_fetch.Hound is one MCP server that gives any agent (Claude Code, Cursor, OpenCode, Hermes, Pi, anything that speaks MCP) full web research from a single local process.
instructions block hands the agent the mental model, the #1 workflow, and the known limits. Effective on turn one.content_ok, next_action, summary, page_type, content_age_days/is_stale, source_type/is_official, relevance_score, fetch_relevance. Agents branch on structured fields, not error text. Hard-blocks (404/bot/auth) return clean errors, not fake content.Hound is for the agent itself. You install it once; the agent calls it whenever it needs the web.
pip install hound-mcp[all] # fetch + crawl + keyless search + PDF + OCR + neural rerank
playwright install chromium # the anti-detect browser engine
Then point any MCP client at the hound command. No arguments, no keys, no env vars. See Install for the lean option and Tell your agent to install it for a copy-paste prompt.
hound -v # version + update status
hound -u # update to latest (brick-proof, self-healing)
hound --doctor # health check + fix advice
hound --rollback # undo the last update
If hound ever breaks (a failed update, a locked launcher), recover with python ~/.hound/repair.py, or run hound --doctor to diagnose.
Hound can run in Docker with HTTP mode, ideal for:
git clone https://github.com/dondai1234/master-fetch.git
cd master-fetch
docker-compose up -d
Hound will be available at http://<your-host-ip>:8765/mcp as an HTTP MCP server (use localhost if running on the same machine).
docker build -t hound-mcp .
docker run -p 8765:8765 hound-mcp
For MCP clients that support HTTP (Claude Code, Open WebUI), use your host's LAN IP:
http://<your-host-ip>:8765/mcp
(Or localhost:8765/mcp if running on the same machine.)
No API key, no account, no third-party service. smart_search runs 10 keyless backends in parallel on your machine, merges, dedups, and ranks. It returns URLs + ranking, not page content: the agent smart_fetches whichever results match what it needs (the ranking is a hint, not a directive).
ms-marco-MiniLM-L-6-v2, Apache-2.0) running on the onnxruntime Hound already ships for OCR. Exa-style semantic ranking, $0, on your machine. Model downloads once (~80MB, cached, not bundled). Lean installs fall back to cross-engine consensus + engine-position order.relevance_score (0–1), fetch_relevance (high/med/low), and engines_consensus.find_similar: pass url=; Hound fetches a page you like, derives a query, and reranks candidates against that source page. Exa's find-similar, local.engine_blocked in the response reports which ones cooled down.site / exclude_sites (domain include/exclusion), location / language / region (geo), page (0–10), freshness (day | week | month | year). Default 6 results. A quality filter drops low-relevance results instead of padding to the max with garbage.related_queries: follow-up queries mined from result titles + snippets (no LLM). Search one to refine a broad query.Search is 100% HTTP: it never touches the browser (the single Patchright browser is smart_fetch's alone).
Scraping public engines from your IP can be rate-limited or CAPTCHA'd. No keyless local tool is bulletproof against sustained blocking without a proxy: Hound is honest about that, then makes the no-proxy case as reliable as possible for a single user:
Same gray-area posture as SearXNG / ddgs; no search-engine ToS compliance is claimed.
Local keyless search scrapes public engines from your IP. Sustained use can get rate-limited. Hound's proxy rotation lets you add multiple proxies and cycles through them automatically: each search call uses the next proxy, spreading traffic across all IPs. Unhealthy proxies (connection errors) are auto-cooled for 60s and skipped. If all proxies are down, Hound falls back to direct connection so search never fails.
Setup in 30 seconds:
# Add proxies (supports http, https, socks5, socks5h + auth)
hound proxy add "http://user:[email protected]:6754"
hound proxy add "socks5://1.2.3.4:1080"
hound proxy add "http://1.2.3.4:8080" "socks5://5.6.7.8:1080" # bulk add
# List configured proxies (credentials redacted)
hound proxy list
# Remove by index or clear all
hound proxy remove 0
hound proxy clear
Or set via env var (comma-separated):
export HOUND_SEARCH_PROXY="http://p1:8080,socks5://p2:1080,http://user:pass@p3:3128"
Max 20 proxies. Config persists in ~/.hound/search_proxies.json. Rotation is per-search-call (not per-engine), so all engines in one search share one IP, and the next search rotates to the next proxy. hound doctor shows your proxy pool status.
Free proxy sources tested with Hound:
Webshare's 10 free proxies are dedicated (yours alone, not shared with other scrapers), which is why they achieve 100% success. ProxyScrape's public list is shared and short-lived, but requires no signup. SOCKS5 outperforms HTTP for search engines because it tunnels HTTPS reliably.
# ProxyScrape: grab working SOCKS5 proxies (no signup needed)
curl -sL "https://api.proxyscrape.com/v4/free-proxy-list/get?request=display_proxies&proxy_format=protocolipport&format=text" | grep "^socks5://" | head -5
# Add them to Hound's rotation pool
# (paste each one: hound proxy add "socks5://ip:port")
Hound's local keyless search works with zero configuration and never goes away. But some users have API keys from search providers, either from free tiers or paid plans. Hound respects that: bring your keys, and Hound makes them first-class citizens with the same reliability guarantees as its own keyless engines.
When keys are configured, those providers become the primary search source and Hound's local keyless engines are completely shut off. This is the entire point of BYOK: avoid hitting public search engines from your IP. The local engines run only as a last-resort fallback when every API key is exhausted or rate-limited, so the search never fails.
Hound uses one provider per search. If you have keys for multiple providers, Hound picks the first available one, and only switches to the next provider when the first is exhausted. This means your search capacity scales with how many keys you configure for a single provider, not with how many providers you stack.
Mix and match. Use one provider, use all five, switch providers anytime. Hound treats them as parallel engines in the same ranking pipeline.
Add multiple keys per provider. Hound stacks them in a rotation pool per provider:
hound keys test makes a real API call per key and reports which are valid, rate-limited, or invalid. Know before you search.This means your search capacity scales with how many keys you configure, not with a single key's rate limit.
# Add a key (stack multiple keys for the same provider)
hound keys add serper YOUR_SERPER_KEY
hound keys add serper ANOTHER_SERPER_KEY # stacked, auto-rotated
hound keys add tavily YOUR_TAVILY_KEY
# List all configured keys (redacted for safety)
hound keys list
# Test all keys (live API call per key)
hound keys test
# Test a specific provider
hound keys test serper
# Remove a specific key by index (0-based)
hound keys remove serper 0
# Remove all keys for a provider
hound keys remove serper
# Remove all keys across all providers
hound keys clear
Keys are stored at ~/.hound/search_keys.json with redaction on display. Key rotation state is in-memory only (resets on restart).
For CI/CD, Docker, or ephemeral environments, set env vars instead of the config file. Comma-separated for multiple keys:
export HOUND_SEARCH_SERPER_KEYS=key1,key2,key3
export HOUND_SEARCH_TAVILY_KEYS=key1
export HOUND_SEARCH_EXA_KEYS=key1
export HOUND_SEARCH_FIRECRAWL_KEYS=key1
export HOUND_SEARCH_TINYFISH_KEYS=key1
Env vars override the config file for any provider that has env vars set. Providers without env vars fall back to the config file. Mix both: some providers in the config file, others via env vars.
hound doctor integrationhound --doctor reports your BYOK configuration status: which providers have keys, how many keys per provider, and whether any are in cooldown. One command to see the full picture.
smart_fetch tries plain HTTP first (~1s). If the site blocks HTTP or serves a JS shell, it auto-escalates to a Patchright anti-detect browser with Cloudflare challenge solving. Two tiers, nothing to configure.
HOUND_BROWSER_IDLE_TIMEOUT, set 0 to keep it alive forever) and relaunches in ~2s on the next fetch. Pages close after each fetch, idle memory stays near baseline. One browser total.channel=chrome for real TLS fingerprint), coherent fingerprint profiles, JS-layer patches (HeadlessChrome UA fix, navigator.webdriver=undefined, canvas noise via getImageData+toDataURL interception, permissions API), human behavior simulation (Bezier mouse curves, natural scroll, dwell time), and a Cloudflare Turnstile solver with human-like mouse movement. See the stealth benchmark below.smart_fetch(url, focus="...") returns only the BM25-relevant blocks. Cuts context 80%+ on long pages, no re-fetch (runs post-cache). Re-pass the same focus when paginating.actions=[{click:'button.load-more'},{fill:{selector:'#q',text:'x'}},{press:'Enter'},{wait:500},{scroll:3},{wait_selector:'.item'}] for load-more, search forms, pagination, infinite scroll. Forces stealthy + bypasses cache.include_links=true populates response.links classified as citations (main-content references, the ones worth following) / navigation / external + a primary_source hint. Follow a page's source chain in one step.css_selector + pages. Bad content is never cached; a size cap evicts the oldest so a long-lived agent's cache can't grow unbounded. cache_ttl=0 forces fresh.next_offset so the agent pages through with one more call (served instantly from cache).Real-world results from v11.1.0, tested against hard anti-bot targets.
Detection test sites (all checks pass):
Anti-bot protected sites (content extracted):
Note: Google Search returns 429 (rate limited) as it uses its own bot detection independent of Cloudflare. This is expected.
Stealth signals verified:
Memory efficiency (5 sequential fetches):
RSS decreased by 3.5 MB over 5 fetches. No RAM creep. The Memory.simulatePressureNotification CDP command triggers Chrome's internal GC + cache drop after each fetch (~5ms, non-disruptive).
smart_crawl walks same-domain links in best-first order: discovered URLs are scored by focus relevance + content-likelihood (docs/guide/api boosted, login/submit/cart penalized) + shallow depth, so content pages are crawled before junk when the budget is tight.
* [title](url) link list; JS shells → detected and reported honestly.options sitemap=true maps the whole site from sitemap.xml in ONE fetch (full URL list + lastmod, no BFS). sitemap='auto' uses it if the site has one, else falls back to BFS. Collapses a hundreds-of-pages discovery crawl into one call.discover_only=true: URL map only (BFS-based). For big sites prefer sitemap=true instead.focus='query': prioritizes relevant pages within the budget AND focus-filters each page's content.crawl_urls=[...]: second-phase selective crawl of a chosen subset (no re-discovery)./docs and /docs/ are never crawled twice. Same-domain only by default; path_include / path_exclude to scope.max_pages (default 10), max_depth (default 2), max_total_chars (token budget), deadline_ms (overall time, default 120000). Each page carries content_ok + status + fetched_at; next_action tells you if the crawl stopped early.smart_fetch detects a PDF (by content-type or %PDF magic bytes) and extracts it to structured markdown with pdfplumber (MIT): multi-column reading order, real tables as markdown tables, font-size headings, de-hyphenated paragraphs, a metadata header, and --- Page N --- markers.
table_of_contents: the PDF outline as [{level, title, page, end_page}]. PDFs without bookmarks get a heading-based fallback map. Pass pages='23-31' to grab one section by range and save tokens.(cid:71)(cid:302)... garbage for figures/diagrams/math. But the glyphs render correctly. Hound detects CID-garbage pages, renders them via pypdfium2, and OCRs them with rapidocr, recovering the real text automatically.[all].quality_score (0.0–1.0) + honest content_ok: trust PDF content more the closer the score is to 1.0.password for encrypted PDFs; include_media=true for per-page image metadata; a .pdf URL that returns a login/paywall is reported as auth_required.screenshot captures a page as an image. For multimodal agents only: use when content is rendered as images / canvas / image-of-text or you need visual layout. Text-only agents should use smart_fetch instead. A stealthy browser session is auto-managed.
Most free web tools for agents do one thing and miss the rest. Hound is the only one that bolts all of it onto a single local MCP server for $0, no keys.
The short version: Crawl4AI crawls well but has no search and trips on Cloudflare. Parallel Search is remote search-only, no crawl, and runs on their servers. Jina fetches but rate-limits and routes through Jina. Firecrawl keeps the good stuff behind the paid cloud. Hound is the only free tool that combines keyless local search, built-in Cloudflare bypass, best-first crawl, scanned-PDF OCR, page interaction, and query-focused extraction in one local MIT server: $0, no accounts, no keys.
Paid scrapers (Bright Data, ZenRows, Firecrawl paid, Spider.cloud) can beat free tools on the hardest anti-bot (DataDome, Akamai, Cloudflare Turnstile) and on massive scale, because they run large residential-proxy networks. Paid search APIs (Exa, Tavily) offer hosted neural search. They cost $16 to $500+/month, require accounts + API keys, and send your queries + content through their servers. Use Hound for $0 local web research with no accounts and no keys; reach for a paid service only for enterprise scale, sites Hound explicitly can't crack, or hosted neural search at scale.
pip install hound-mcp[all] # recommended: fetch + crawl + keyless search + PDF + OCR + neural rerank
playwright install chromium
pip install hound-mcp # fetch + crawl + keyless search (HTTP-only, no stealthy browser)
The lean install works on all platforms (including Termux/Android). It gives you
multi-engine keyless search, HTTP fetch with auto-escalation (HTTP tier only, no
stealthy browser), crawl, and caching. Stealthy browser escalation and screenshot
require browser deps from the [all] extra.
No API keys or accounts are needed for anything: search is keyless and local.
hound -u # update to latest (brick-proof: --no-deps, detached helper, self-heal)
hound --doctor # health check: launcher, imports, metadata, deps, PyPI, repair script
hound --rollback # reinstall the version from before the last update
hound -u is designed to never brick the install. It updates with --no-deps (no heavy extras that fail mid-install); on Windows it runs pip in a detached helper after the launcher exits (Windows can't overwrite a running .exe), freeing the launcher via the rename trick. If a pip pass leaves the version unchanged, it self-heals with a --force-reinstall --no-deps pass.
If hound is ever broken (a failed manual pip while a server held the launcher, a half-finished update), the safety net is a standalone script written outside site-packages on every update:
python ~/.hound/repair.py # stops hound, force-reinstalls hound-mcp from PyPI, verifies
It survives because it is not part of the hound-mcp package, so a failed pip uninstall never removes it. hound --doctor diagnoses the install and tells you the right fix.
Paste this into your agent:
Install the Hound MCP server on this machine. Follow every step. Do not skip any.
1. Figure out which agent harness you are running on (OpenCode, Hermes, Pi, etc). Then find: (a) where the MCP config file lives, and (b) what format it expects for adding a local MCP server. Read the harness docs if needed. Do not guess.
2. Run: pip install hound-mcp[all]
Then run: playwright install chromium (But only if it isnt installed already, verify first about its existence)
If either fails, stop and tell the user.
3. Find the MCP config file from step 1 and back it up before editing. Add a new MCP server named "hound" with command "hound", no arguments, in the format your harness requires. No API keys or environment variables are needed (search is keyless and local).
4. Save the file. Tell the user to restart the agent. After restart, smart_fetch, smart_crawl, smart_search, screenshot, cache_clear and version should be available.
Install the Hound MCP server, then the Pi extension:
pip install hound-mcp[all]
pi install npm:@houndmcp/hound-mcp-pi
No API keys, no config file, no MCP adapter needed. The extension spawns hound as a singleton subprocess and registers all 6 tools (web_fetch, web_search, web_crawl, web_screenshot, cache_clear, hound_version) as native Pi tools. Prewarmed at session start. Run /reload to activate.
Updating:
hound -u # update the MCP server
pi update npm:@houndmcp/hound-mcp-pi # update the extension
The extension checks version sync at session start and warns if the extension and hound diverge by a major version.
Open WebUI v0.6.31+ speaks the streamable HTTP transport natively. Run Hound in HTTP mode and point Open WebUI at it, no mcpo proxy needed:
hound --http --host 127.0.0.1 --port 8765
Then in Open WebUI add an MCP server with URL http://127.0.0.1:8765/mcp. Stdio clients (Claude Code, Cursor, OpenCode, Pi, etc.) just use hound with no flag.
Things that might surprise you if you don't know them:
No free tool can do everything. Hound is upfront about what it can't:
When a fetch or search fails, the response says exactly why and what to try next, so the agent doesn't waste calls guessing.
Most MCP servers cost 3–5K tokens just to exist. Hound's 6 tools cost ~2.7K tokens at tools/list (measured with cl100k_base); the connect-time instructions (~0.8K, the orientation doc) are injected ONCE at handshake, not repeated every turn. Your context window is expensive; Hound respects it.
MCP server for web fetching with Cloudflare bypass, Trafilatura extraction, and smart routing. Free, self-hosted, no API keys.
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Master Fetch stdio पर लोकल चलता है।
पिछली जाँच 2026-10-27 को हुई। MCP server for web fetching with Cloudflare bypass, Trafilatura extraction, and smart routing. Free, self-hosted, no API keys.